protected override BlockProcessor CreateBlockProcessor()
{
AbiEncoder abiEncoder = AbiEncoder.Instance;
ReadOnlyTransactionProcessorSource = new ReadOnlyTxProcessingEnv(
DbProvider,
new TrieStore(DbProvider.StateDb, LimboLogs.Instance).AsReadOnly(),
BlockTree, SpecProvider,
LimboLogs.Instance);
RegisterContract = new RegisterContract(abiEncoder, ChainSpec.Parameters.Registrar, ReadOnlyTransactionProcessorSource);
CertifierContract = new CertifierContract(
abiEncoder,
RegisterContract,
ReadOnlyTransactionProcessorSource);
return(new AuRaBlockProcessor(
SpecProvider,
Always.Valid,
new RewardCalculator(SpecProvider),
new BlockProcessor.BlockValidationTransactionsExecutor(TxProcessor, State),
State,
Storage,
ReceiptStorage,
LimboLogs.Instance,
BlockTree));
}
public async Task <IActionResult> UpdateAsync([FromBody] RegisterContract command)
{
try
{
if (ModelState.IsValid)
{
// insert contract
Contract contract = Mapper.Map <Contract>(command);
_dbContext.Contracts.Update(contract);
await _dbContext.SaveChangesAsync();
// send event
//RateRegistered e = Mapper.Map<RateRegistered>(command);
//await _messagePublisher.PublishMessageAsync(e.MessageType, e, "");
// return result
return(CreatedAtRoute("GetByContractId", new { contractId = contract.ContractId }, contract));
}
return(BadRequest());
}
catch (DbUpdateException ex)
{
ModelState.AddModelError("", "Unable to save changes. " +
"Try again, and if the problem persists " +
"see your system administrator." + " -" + ex.Message);
return(StatusCode(StatusCodes.Status500InternalServerError));
}
}
public async Task <IActionResult> Register(RegisterContract model)
{
await _userService.CreateRole("user");
//await _userService.CreateRole("admin");
var userDto = new UserDto
{
Email = model.Email,
Password = model.Password,
UserName = model.UserName,
Role = "user"
};
var id = await _userService.Create(userDto);
if (string.IsNullOrEmpty(id))
{
return(BadRequest());
}
var token = await _userService.GenerateToken(id);
if (string.IsNullOrEmpty(token))
{
return(BadRequest());
}
//var callbackUrl = Url.Action("ConfirmEmail", "Account", new { userId = id, code = token }, protocol: HttpContext.Request.Scheme);
var callbackUrl = QueryHelpers.AddQueryString("http://localhost:4200/confirmemail", new Dictionary <string, string>()
{
{ "userId", id }, { "code", token }
});
EmailService emailService = new EmailService();
await emailService.SendEmailAsync(model.Email, "Confirm your account", $"Подтвердите регистрацию на \"PetSharing\", перейдя по ссылке: <a href='{callbackUrl}'>link</a>");
return(Ok(true));
}
public async Task registry_contract_returns_not_found_when_contract_doesnt_exist()
{
using var chain = await TestContractBlockchain.ForTest <TestTxPermissionsBlockchain, TxCertifierFilterTests>();
var contract = new RegisterContract(AbiEncoder.Instance, Address.FromNumber(1000), chain.ReadOnlyTransactionProcessorSource);
contract.TryGetAddress(chain.BlockTree.Head.Header, CertifierContract.ServiceTransactionContractRegistryName, out Address _).Should().BeFalse();
}
public async Task <IActionResult> Register([FromBody] RegisterContract request)
{
try
{
var user = await accountService.Register(request.Name, request.Password, request.Email);
return(Json(user));
}
catch (Exception exception)
{
return(BadRequest(new { errorText = exception.Message }));
}
}
protected override ITxFilter CreateGasPriceTxFilter(ReadOnlyTxProcessorSource readOnlyTxProcessorSource)
{
ITxFilter gasPriceTxFilter = base.CreateGasPriceTxFilter(readOnlyTxProcessorSource);
Address? registrar = _api.ChainSpec?.Parameters.Registrar;
if (registrar != null)
{
RegisterContract registerContract = new RegisterContract(_api.AbiEncoder, registrar, readOnlyTxProcessorSource);
CertifierContract certifierContract = new CertifierContract(_api.AbiEncoder, registerContract, readOnlyTxProcessorSource);
return(new TxCertifierFilter(certifierContract, gasPriceTxFilter, _api.LogManager));
}
return(gasPriceTxFilter);
}
public async Task <IActionResult> Register(RegisterContract contract)
{
using var store = Service.DataStore.OpenSession();
var account = await store
.Query <Account>()
.FirstOrDefaultAsync(a => a.Username == contract.Username);
if (account != null)
{
return(Unauthorized("Account already exists"));
}
account = new Account
{
Username = contract.Username,
Password = BCrypt.Net.BCrypt.HashPassword(contract.Password)
};
await store.InsertAsync(account);
return(Ok(GetToken(account)));
}
private static ITxFilter CreateBaseAuRaTxFilter(
IMiningConfig miningConfig,
AuRaNethermindApi api,
IReadOnlyTxProcessorSource readOnlyTxProcessorSource,
IDictionaryContractDataStore <TxPriorityContract.Destination>?minGasPricesContractDataStore)
{
ITxFilter gasPriceTxFilter = CreateStandardTxFilter(miningConfig);
if (minGasPricesContractDataStore != null)
{
gasPriceTxFilter = new MinGasPriceContractTxFilter(gasPriceTxFilter, minGasPricesContractDataStore);
}
Address?registrar = api.ChainSpec?.Parameters.Registrar;
if (registrar != null)
{
RegisterContract registerContract = new RegisterContract(api.AbiEncoder, registrar, readOnlyTxProcessorSource);
CertifierContract certifierContract = new CertifierContract(api.AbiEncoder, registerContract, readOnlyTxProcessorSource);
return(new TxCertifierFilter(certifierContract, gasPriceTxFilter, api.LogManager));
}
return(gasPriceTxFilter);
}
public JsonResult AddMerchantDetails([FromBody] RegisterContract registerContract)
{
Merchant merchant = new Merchant();
merchant.Name = registerContract.Name;
merchant.OrganizationName = registerContract.Organization;
merchant.Address = registerContract.Address;
merchant.Phone = registerContract.Phone;
registerContract.id = _merchantRepository.AddMerchantDetails(merchant);
Employee employee = new Employee();
employee.Name = registerContract.Name;
employee.Phone = registerContract.Phone;
employee.Email = registerContract.Email;
employee.Username = registerContract.Username;
employee.Password = registerContract.Password;
employee.Dateofjoining = DateTime.UtcNow;
employee.MerchantId = merchant.MerchantId;
employee.DesignationId = 1;
_employeeRepository.AddEmployee(merchant.MerchantId, employee);
return(Json(registerContract));
}
