public void Execute(bool invalid, bool pendingExist, bool alreadyActivated, Type exc)
{
var nonce = new byte[] { 0x00, 0x01, 0x02, 0x03 };
var privateKey = new PrivateKey();
(ActivationKey activationKey, PendingActivationState pendingActivation) =
ActivationKey.Create(privateKey, nonce);
Address activatedAddress = default(Address).Derive(ActivationKey.DeriveKey);
var state = new State();
if (pendingExist)
{
state = (State)state.SetState(pendingActivation.address, pendingActivation.Serialize());
}
if (alreadyActivated)
{
state = (State)state.SetState(activatedAddress, true.Serialize());
}
ActivateAccount action = activationKey.CreateActivateAccount(invalid ? new byte[] { 0x00 } : nonce);
if (exc is null)
{
IAccountStateDelta nextState = action.Execute(new ActionContext()
{
PreviousStates = state,
Signer = default,
public ActivationStatusMutation()
{
Field <NonNullGraphType <BooleanGraphType> >("activateAccount",
arguments: new QueryArguments(
new QueryArgument <NonNullGraphType <StringGraphType> >
{
Name = "encodedActivationKey",
}),
resolve: context =>
{
try
{
string encodedActivationKey =
context.GetArgument <string>("encodedActivationKey");
NineChroniclesNodeService service = context.Source;
// FIXME: Private key may not exists at this moment.
PrivateKey privateKey = service.PrivateKey;
ActivationKey activationKey = ActivationKey.Decode(encodedActivationKey);
BlockChain <NineChroniclesActionType> blockChain = service.Swarm.BlockChain;
IValue state = blockChain.GetState(activationKey.PendingAddress);
if (!(state is Bencodex.Types.Dictionary asDict))
{
context.Errors.Add(new ExecutionError("The given key was already expired."));
return(false);
}
var pendingActivationState = new PendingActivationState(asDict);
ActivateAccount action = activationKey.CreateActivateAccount(
pendingActivationState.Nonce);
var actions = new NineChroniclesActionType[] { action };
blockChain.MakeTransaction(privateKey, actions);
}
public ActionResult ConfirmedEmail(ActivateAccount objAcct)
{
if (ModelState.IsValid)
{
//Check if valid username and password
if (regClass.CheckUserIfExist(objAcct.Username, objAcct.Password) == true)
{
//check if accescode is correct
if (regClass.CheckUserAccessCodeIfExist(objAcct.Username, objAcct.Password, objAcct.Accesscode) == true)
{
//Goto Login Page
return(this.RedirectToAction("SuccessRegister", "MemberAccount"));
}
else
{
ModelState.AddModelError("Warning", "Incorrect Access Code, Please check your Email.");
}
}
else
{
ModelState.AddModelError("Warning", "Incorrect Username and Password.");
}
}
else
{
return(View());
}
return(View());
}
public void ActivateAccount(bool invalid, int expectedCode)
{
var nonce = new byte[] { 0x00, 0x01, 0x02, 0x03 };
var privateKey = new PrivateKey();
(ActivationKey activationKey, PendingActivationState _) = ActivationKey.Create(privateKey, nonce);
string invitationCode = invalid ? "invalid_code" : activationKey.Encode();
var filePath = Path.Combine(Path.GetTempPath(), Path.GetTempFileName());
var resultCode = _command.ActivateAccount(invitationCode, ByteUtil.Hex(nonce), filePath);
Assert.Equal(expectedCode, resultCode);
if (resultCode == 0)
{
var rawAction = Convert.FromBase64String(File.ReadAllText(filePath));
var decoded = (List)_codec.Decode(rawAction);
string type = (Text)decoded[0];
Assert.Equal(nameof(Nekoyume.Action.ActivateAccount), type);
Dictionary plainValue = (Dictionary)decoded[1];
var action = new ActivateAccount();
action.LoadPlainValue(plainValue);
Assert.Equal(activationKey.PrivateKey.Sign(nonce), action.Signature);
Assert.Equal(activationKey.PendingAddress, action.PendingAddress);
}
else
{
Assert.Contains("hexWithSlash seems invalid. [invalid_code]", _console.Error.ToString());
}
}
public object Any(ActivateAccount request)
{
var response = Global.RequestsProcessor.Any(request);
TransferHeader(request, response);
return(response);
}
public void Execute()
{
var nonce = new byte[] { 0x00, 0x01, 0x02, 0x03 };
var privateKey = new PrivateKey();
(ActivationKey activationKey, PendingActivationState pendingActivation) =
ActivationKey.Create(privateKey, nonce);
var state = new State(ImmutableDictionary <Address, IValue> .Empty
.Add(ActivatedAccountsState.Address, new ActivatedAccountsState().Serialize())
.Add(pendingActivation.address, pendingActivation.Serialize()));
ActivateAccount action = activationKey.CreateActivateAccount(nonce);
IAccountStateDelta nextState = action.Execute(new ActionContext()
{
PreviousStates = state,
Signer = default,
public async Task <ActionResult> ActivateAccount(ActivateAccount activateAccount)
{
if (activateAccount.Email == null || activateAccount.Token == null)
{
return(Ok());
}
Customer customer = await userManager.FindByEmailAsync(activateAccount.Email);
if (customer == null)
{
return(Ok());
}
if (customer.EmailConfirmed)
{
return(Ok());
}
var result = await userManager.ConfirmEmailAsync(customer, activateAccount.Token);
if (result.Succeeded)
{
List <Claim> claims = GetClaims(customer, true);
return(Ok(new
{
tokenData = await GenerateTokenData(customer, claims),
customer = new CustomerData
{
FirstName = customer.FirstName,
LastName = customer.LastName,
Email = customer.Email,
Image = customer.Image
}
}));
}
return(Ok());
}
public ActivationStatusMutation(NineChroniclesNodeService service)
{
Field <NonNullGraphType <BooleanGraphType> >("activateAccount",
arguments: new QueryArguments(
new QueryArgument <NonNullGraphType <StringGraphType> >
{
Name = "encodedActivationKey",
}),
resolve: context =>
{
try
{
string encodedActivationKey =
context.GetArgument <string>("encodedActivationKey");
// FIXME: Private key may not exists at this moment.
if (!(service.MinerPrivateKey is { } privateKey))
{
throw new InvalidOperationException($"{nameof(privateKey)} is null.");
}
ActivationKey activationKey = ActivationKey.Decode(encodedActivationKey);
if (!(service.Swarm?.BlockChain is { } blockChain))
{
throw new InvalidOperationException($"{nameof(blockChain)} is null.");
}
IValue state = blockChain.GetState(activationKey.PendingAddress);
if (!(state is Bencodex.Types.Dictionary asDict))
{
context.Errors.Add(new ExecutionError("The given key was already expired."));
return(false);
}
var pendingActivationState = new PendingActivationState(asDict);
ActivateAccount action = activationKey.CreateActivateAccount(
pendingActivationState.Nonce);
var actions = new NCAction[] { action };
blockChain.MakeTransaction(privateKey, actions);
}
public IActionResult ActivateAccount(ActivateAccount model)
{
if (ModelState.IsValid)
{
var user = _db.UsersGenericRepository.Where(u => u.ActiveCode == model.Code).FirstOrDefault();
if (user != null)
{
user.ActiveCode = CodeGenerator.EmailCode();
user.IsActive = true;
_db.UsersGenericRepository.Update(user);
_db.Save();
return(RedirectToAction("Index", "Home"));
}
else
{
ModelState.AddModelError("Code", "کد فعالسازی صحیح نیست");
return(View(model));
}
}
else
{
return(View(model));
}
}
public IHttpActionResult ChangeEmail(int id, ChangeEmailModel model)
{
var user = db.User.Where(u => u.Id == id).FirstOrDefault();
var account = db.UserAccount.Where(u => u.UserId == id).FirstOrDefault();
if (user == null || account == null)
{
return(BadRequest());
}
user.Email = model.Email;
account.LoginId = model.Email;
account.IsEnable = false;
db.User.Attach(user);
db.Entry(user).Property(e => e.Email).IsModified = true;
db.UserAccount.Attach(account);
db.Entry(account).Property(e => e.LoginId).IsModified = true;
db.Entry(account).Property(e => e.IsEnable).IsModified = true;
ActivateAccount activateaccount = new ActivateAccount
{
UID = Authentication.RandomString(50, true),//random alphanumeric
UserId = user.Id,
CreatedDate = DateTime.Now,
IsActivate = false
};
db.ActivateAccount.Add(activateaccount);
db.Configuration.ValidateOnSaveEnabled = false;
db.SaveChanges();
return(Ok(new { UserId = user.Id, UID = activateaccount.UID }));
}
public ActivateAccountResponse PostActivateAccount(ActivateAccount request)
{
var response = Post <ActivateAccount, ActivateAccountResponse>("ActivateAccount", request);
return(response);
}
public IHttpActionResult Post([FromBody] CreateCompanyModel model)
{
if (model.Type == CompanyType.Government)
{
ModelState.Remove("model.PassportNo");
ModelState.Remove("model.PostCodeNonMalaysian");
ModelState.Remove("model.State");
ModelState.Remove("model.CountryId");
ModelState.Remove("model.CompanyName");
ModelState.Remove("model.CompanyRegNo");
ModelState.Remove("model.SectorId");
}
else if (model.Type == CompanyType.MalaysianCompany)
{
ModelState.Remove("model.PassportNo");
ModelState.Remove("model.PostCodeNonMalaysian");
ModelState.Remove("model.State");
ModelState.Remove("model.CountryId");
ModelState.Remove("model.AgencyName");
ModelState.Remove("model.MinistryId");
}
else
{
ModelState.Remove("model.ICNo");
ModelState.Remove("model.PostCodeMalaysian");
ModelState.Remove("model.StateId");
ModelState.Remove("model.AgencyName");
ModelState.Remove("model.MinistryId");
ModelState.Remove("model.CompanyRegNo");
}
if (ModelState.IsValid)
{
var countryCode = db.Country.Where(c => c.Id == model.CountryId && c.Display).FirstOrDefault();
if (countryCode == null)
{
return(InternalServerError());
}
var password = "******";
if (FEPHelperMethod.CurrentSystemMode() != SystemMode.Development)
{
password = Authentication.RandomString(10, true);
}
Authentication.GeneratePassword(password);
var account = new UserAccount
{
LoginId = model.Email,
IsEnable = false,
HashPassword = Authentication.HashPassword,
Salt = Authentication.Salt,
LoginAttempt = 0
};
var company = new CompanyProfile
{
Type = model.Type,
CompanyName = model.Type == CompanyType.Government ? model.AgencyName : model.CompanyName,
MinistryId = model.MinistryId,
CompanyRegNo = model.CompanyRegNo,
SectorId = model.SectorId,
Address1 = model.Address1,
Address2 = model.Address2,
City = model.City,
PostCode = model.Type == CompanyType.NonMalaysianCompany ? model.PostCodeNonMalaysian : model.PostCodeMalaysian,
StateId = model.StateId,
StateName = model.State,
CountryId = model.CountryId,
CompanyPhoneNo = model.CompanyPhoneNo,
CountryCode = countryCode.CountryCode1
};
var user = new User
{
UserType = UserType.Company,
Name = model.Name,
Email = model.Email,
ICNo = model.Type == CompanyType.NonMalaysianCompany ? model.PassportNo : model.ICNo,
MobileNo = model.MobileNo,
CountryCode = countryCode.CountryCode1,
Display = true,
CreatedBy = null,
CreatedDate = DateTime.Now,
UserAccount = account,
CompanyProfile = company
};
foreach (var roleid in model.RoleIds)
{
var userrole = new UserRole
{
RoleId = roleid,
UserAccount = account,
};
db.UserRole.Add(userrole);
}
db.User.Add(user);
ActivateAccount activateaccount = new ActivateAccount
{
UID = Authentication.RandomString(50, true),//random alphanumeric
UserId = user.Id,
CreatedDate = DateTime.Now,
IsActivate = false
};
db.ActivateAccount.Add(activateaccount);
db.SaveChanges();
return(Ok(new { UserId = user.Id, Password = password, UID = activateaccount.UID }));
}
return(BadRequest(ModelState));
}
public bool Verify(ActivateAccount action)
{
return(Verify(action.Signature));
}
public async Task HandleAsync(ActivateAccount command) => await CreateAsync(command);
public ResponseBase Any(ActivateAccount request)
{
_logger.Log(EErrorType.Info, " ****** Call start: ActivateAccount");
ActivateAccountResponse response = new ActivateAccountResponse();
try
{
GetUserAccountInfoParams accParams = new GetUserAccountInfoParams();
accParams.Email = request.Email;
GetUserAccountInfoResult accResult = _dal.GetUserAccountInfo(accParams);
if (accResult != null)
{
if (accResult.ActivationCode == request.ActivationCode)
{
CreateUpdateUserAccountParams updateParams = new CreateUpdateUserAccountParams();
updateParams.AccountKey = accResult.AccountKey;
updateParams.State = "active"; // TODO: need to change to consts
_dal.UpdateUserAccount(updateParams);
response.Success = true;
}
else
{
response.Success = false;
response.Errors.Add(new Error()
{
Code = EErrorCodes.UserAccountNotValidated,
Type = EErrorType.Error,
Message = "Invalid activation code provided - account was not activated"
}
);
}
}
else
{
response.Success = false;
response.Errors.Add(new Error()
{
Code = EErrorCodes.UserAccountNotFound,
Type = EErrorType.Error,
Message = "User account was not found."
}
);
}
}
catch (Exception ex)
{
_logger.Log(ex);
response.Success = false;
response.Errors.Add(new Error()
{
Code = EErrorCodes.GeneralError,
Type = EErrorType.Error,
Message = string.Format("Unexpected error: {0}", ex.Message)
});
}
_logger.Log(EErrorType.Info, " ****** Call end: ActivateAccount");
return(response);
}
public bool Verify(ActivateAccount action)
{
return(PublicKey.Verify(Nonce, action.Signature));
}
public IHttpActionResult RegisterIndividual([FromBody] RegisterIndividualModel model)
{
if (model.IsMalaysian)
{
ModelState.Remove("model.PassportNo");
ModelState.Remove("model.CitizenshipId");
ModelState.Remove("model.PostCodeNonMalaysian");
ModelState.Remove("model.State");
}
else
{
ModelState.Remove("model.ICNo");
ModelState.Remove("model.PostCodeMalaysian");
ModelState.Remove("model.StateId");
}
if (ModelState.IsValid)
{
var countryCode = db.Country.Where(c => c.Id == model.CountryId && c.Display).FirstOrDefault();
if (countryCode == null)
{
return(InternalServerError());
}
Authentication.GeneratePassword(model.Password);
//get default role
var roles = db.RoleDefault.Where(r => r.DefaultRoleType == DefaultRoleType.DefaultIndividual).ToList();
List <UserRole> userroles = new List <UserRole>();
foreach (var role in roles)
{
userroles.Add(new UserRole {
Role = role.Role
});
}
var account = new UserAccount
{
LoginId = model.Email,
IsEnable = false,
HashPassword = Authentication.HashPassword,
Salt = Authentication.Salt,
LoginAttempt = 0,
UserRoles = userroles
};
var individual = new IndividualProfile
{
IsMalaysian = model.IsMalaysian,
CitizenshipId = model.CitizenshipId,
Address1 = model.Address1,
Address2 = model.Address2,
PostCode = model.IsMalaysian ? model.PostCodeMalaysian : model.PostCodeNonMalaysian,
City = model.City,
StateName = model.State,
StateId = model.StateId,
CountryId = model.CountryId
};
var user = new User
{
UserType = UserType.Individual,
Name = model.Name,
Email = model.Email,
ICNo = model.IsMalaysian ? model.ICNo : model.PassportNo,
MobileNo = model.MobileNo,
CountryCode = countryCode.CountryCode1,
Display = true,
CreatedBy = null,
CreatedDate = DateTime.Now,
UserAccount = account,
IndividualProfile = individual
};
db.User.Add(user);
ActivateAccount activateAccount = new ActivateAccount
{
UID = Authentication.RandomString(50, true),//random alphanumeric
UserId = user.Id,
CreatedDate = DateTime.Now,
IsActivate = false
};
db.ActivateAccount.Add(activateAccount);
db.SaveChanges();
return(Ok(new { UserId = user.Id, UID = activateAccount.UID }));
}
return(BadRequest(ModelState));
}
