public ActionResult CreateAccount(string textUsername, string textPassword, string textAddress, string textPhoneNumber, string textEmail, bool accountType)
{
CreateAccount msg = new CreateAccount
{
username = textUsername,
password = textPassword,
address = textAddress,
phonenumber = textPhoneNumber,
email = textEmail,
type = accountType ? AccountType.business : AccountType.user
};
CreateAccountRequest request = new CreateAccountRequest(msg);
ServiceBusResponse response = ConnectionManager.sendNewAccountInfo(request);
if (response.result == true)
{
return(RedirectToAction("Index", "Home"));
}
ViewBag.AccountCreationResult = response.response;
return(View("CreateAccount"));
}
public async Task <IActionResult> CreateAccount(
[FromBody] CreateAccountRequest request,
CancellationToken token)
{
var query = new CreateCommand(
request.AccountName,
CorrelationContext.Get());
var response = await _mediator
.Send(
query,
token);
if (!response
.ValidationResult
.IsValid)
{
var errors = string.Empty;
response
.ValidationResult
.Errors
.ToList()
.ForEach(e => { errors += $"{e}//r//n"; });
return(BadRequest(errors));
}
return(Ok(new CreateAccountView(
response.AccountName,
response.AccountNumber,
response.Balance)));
}
public async Task <IHttpActionResult> CreateAccount(CreateAccountRequest request)
{
var user = new HaloUser
{
UserName = request.Username
};
var creationResult = await _userManager.CreateAsync(user, request.Password);
if (creationResult.Succeeded == false)
{
return(BadRequest(string.Join(", ", creationResult.Errors)));
}
var userBaseData = new UserBaseData
{
User = new UserId
{
Id = user.UserId
},
Nickname = request.Nickname,
BattleTag = "",
Level = 0,
Clan = new ClanId
{
Id = 0
},
ClanTag = ""
};
await _userBaseDataRepository.SetUserBaseDataAsync(userBaseData);
var token = AuthenticateUser(user);
return(Ok(token));
}
public void CreateUser(CreateAccountRequest request)
{
Require.NotNull(request, nameof(request));
var doesExist = EnumerableExtensions.Any(GetUserList(account => account.Email.Address == request.Email));
if (doesExist)
{
throw new AccountAlreadyExistsException();
}
var newAccount = new Account(
request.Firstname,
request.Lastname,
new MailAddress(request.Email),
new Password(request.Password),
AccountRole.User,
ConfirmationStatus.Unconfirmed,
DateTime.Now,
request.Profile);
var userId = _userRepository.CreateAccount(newAccount);
_confirmationService.SetupEmailConfirmation(userId);
}
public IActionResult CreaeteUserAccount([FromBody] CreateAccountRequest accUserRequest)
{
if (Exited(accUserRequest.Email))
{
return(StatusCode(400, new { message = "Account already existed" }));
}
var account = _mapper.Map <Account>(accUserRequest);
account.Password = Encode(account.Password);
_accountservice.Create(account);
CreateRoleForAccount(account.Email, "user");
var accountget = _accountservice.Get(a => a.Email.Equals(account.Email), null);
User user = new User();
user.AccountId = accountget.Id;
_userService.Create(user);
var roleid = _accountroleservice.Get(a => a.AccountId == accountget.Id, null).RoleId;
var role = _roleservice.Get(a => a.Id == roleid, null).Name;
var accountreponse = _mapper.Map <AccountResponse>(accountget);
accountreponse.Role.Add(role);
string tokenStr = GenerateJSONWebToken(accountreponse);
return(StatusCode(200, new { token = tokenStr, id = accountget.Id, role = accountreponse.Role }));
}
public HttpResponseMessage Post([FromBody] CreateAccountRequest request)
{
if (!ModelState.IsValid)
{
return(Request.CreateResponse(HttpStatusCode.BadRequest, new CreateAccountResponse()
{
code = -1,
message = ModelState.FirstOrDefault().Value.Errors.FirstOrDefault().ErrorMessage
}));
}
bool isSuccess = _accountService.CreateAccount(request.mobile_number, request.first_name, request.last_name, request.date_of_birth, request.gender, request.email);
if (isSuccess)
{
return(Request.CreateResponse(HttpStatusCode.OK, new CreateAccountResponse()
{
code = 1,
message = "Successfully created your account."
}));
}
return(Request.CreateResponse(HttpStatusCode.InternalServerError, new CreateAccountResponse()
{
code = -2,
message = "System failed to created your account."
}));
}
public IHttpActionResult RegisterNewDeveloper([FromBody] RegisterDeveloperRequest request)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var createAccountRequest = new CreateAccountRequest(
new MailAddress(request.Email),
request.LastName,
request.FirstName,
request.Password,
new Profile
{
InstituteName = request.InstituteName,
PhoneNumber = request.PhoneNumber,
Specialization = request.StudyingProfile,
StudentAccessionYear = request.AccessionYear,
StudyingDirection = request.Department,
VkProfileUri = request.VkProfileUri == null ? null : new Uri(request.VkProfileUri)
});
try
{
_userManager.CreateUser(createAccountRequest);
}
catch (AccountAlreadyExistsException)
{
return(ResponseMessage(new HttpResponseMessage(HttpStatusCode.Conflict)));
}
return(Ok());
}
public async Task <CreateAccountResponse> CreateAccount(CreateAccountRequest request, CancellationToken cancellationToken)
{
var account = _mapper.Map <CreateAccountRequest, Account>(request);
var accountIdentity = _mapper.Map <CreateAccountRequest, AccountIdentity>(request);
accountIdentity.HashedPassword = PasswordHasher.HashPassword(request.Password !);
using (var session = await _databaseSessionProvider.StartSession(cancellationToken))
{
var accountRepository = session.GetRepository <Account>();
var accountIdentityRepository = session.GetRepository <AccountIdentity>();
session.StartTransaction();
await accountRepository.InsertAsync(account, cancellationToken);
accountIdentity.Id = account.Id; //account and identity should has same id
await accountIdentityRepository.InsertAsync(accountIdentity, cancellationToken);
await session.CommitTransactionAsync(cancellationToken);
}
var token = await GetJwtToken(request.Username !, request.Password !, cancellationToken);
return(new CreateAccountResponse(token));
}
} //end of public async Task<WalletGeneralInfoResponse> GetWalletGeneralInfo()
/// <summary>
/// Generate A New Account In The Wallet
/// </summary>
/// <param name="walletName">Wallet Name</param>
/// <param name="password">Wallet Password</param>
/// <returns></returns>
public async Task <string> CreateAccount(string walletName, string password)
{
try
{
Guard.Null(walletName, nameof(walletName), "Unable To Create Wallet Account, Provided Name Is NULL/Empty!");
Guard.Null(password, nameof(password), "Unable To Create Wallet Account, Provided Password Is NULL/Empty!");
CreateAccountRequest request = new CreateAccountRequest
{
walletName = walletName,
password = password
};
string response = await base.SendPostJSON <string>("api/Wallet/account", request);
Guard.Null(response, nameof(response), "'api/Wallet/account' API Response Was Null!");
return(response);
}
catch (Exception ex)
{
Logger.Fatal($"An Error '{ex.Message}' Occured When Creating Wallet Account Info, For Wallet '{walletName.Trim()}'!", ex);
throw;
} //end of try-catch
} //end of public async Task<string> CreateAccount(string walletName, string password)
/// <summary>
/// This function is called by the client on the users computer when they request to create account
/// </summary>
/// <param name="username">The clients desired username</param>
/// <param name="password">The clients password</param>
/// <param name="address">The clients address</param>
/// <param name="accountType">The clients account type (user, business, or notspecified)</param>
/// <param name="email">The clients desired email address</param>
/// <param name="phonenumber">The clients phonenumber</param>
/// <returns>Either redirects to homepage on correct log in or returns an error message to the log in screen</returns>
public ActionResult UserCreateAccount(string username, string password, string address, string phonenumber, string email, string accountType)
{
var account = AccountType.notspecified;
switch (accountType)
{
case "user":
account = AccountType.user;
break;
case "business":
account = AccountType.business;
break;
}
phonenumber = phonenumber.Replace(" ", "").Replace("(", "").Replace(")", "").Replace("-", "");
CreateAccountRequest request = new CreateAccountRequest(new CreateAccount()
{
username = username,
password = password,
address = address,
email = email,
phonenumber = phonenumber,
type = account
});
ServiceBusResponse response = ConnectionManager.sendNewAccountInfo(request);
if (response.result)
{
return(RedirectToAction("Index", "Home", new { msg = "Hello " + username + " account successfully created!" }));
}
ViewBag.CreateAccountResponse = response.response;
return(View("CreateAccount"));
}
/// <summary>
/// Post /createAccount API call
/// </summary>
/// <param name="createAccountRequest"></param>
/// <returns>CloseAccountResponse</returns>
public CreateAccountResponse CreateAccount(CreateAccountRequest createAccountRequest)
{
var jsonRequest = Util.JsonOperation.SerializeRequest(createAccountRequest);
var jsonResponse = _createAccount.Request(jsonRequest);
return(JsonConvert.DeserializeObject <CreateAccountResponse>(jsonResponse));
}
/**
* Creates an account.
*/
private static void SetupUserFromCreateAccountRequest(User user, CreateAccountRequest createAccountRequest)
{
Debug.Untested();
Debug.AssertValid(user);
Debug.AssertValid(createAccountRequest);
user.ClientID = createAccountRequest.clientId;
user.GivenName = createAccountRequest.givenName;
user.FamilyName = createAccountRequest.familyName;
user.DateOfBirth = (DateTime)APIHelper.DateFromAPIDateString(createAccountRequest.dateOfBirth);
user.Address1 = createAccountRequest.address1;
user.Address2 = createAccountRequest.address2;
user.Address3 = createAccountRequest.address3;
user.Address4 = createAccountRequest.address4;
user.City = createAccountRequest.city;
user.Region = createAccountRequest.region;
user.Country = createAccountRequest.country;
user.PostalCode = createAccountRequest.postalCode;
user.AllowNonEssentialEmails = createAccountRequest.allowNonEssentialEmails;
if (createAccountRequest.allowNonEssentialEmails)
{
user.ANEEOnTimestamp = DateTime.Now;
}
else
{
user.ANEEOffTimestamp = DateTime.Now;
}
}
public BaseResponse <GetAccountResponse> CreateAccount(CreateAccountRequest request)
{
var method = HttpMethod.Post;
var endpoint = $"/accounts";
return(this.HttpClientUtil.SendRequest <GetAccountResponse>(method, endpoint, request, authMode: "amk"));
}
public ActionResult SaveAccount(CreateAccount account)
{
//Save this account info
CreateAccountRequest request = new CreateAccountRequest(account);
ServiceBusResponse response;
ServiceBusConnection connection = ConnectionManager.getConnectionObject(Globals.getUser());
if (connection == null)
{
response = ConnectionManager.sendNewAccountInfo(request);
}
else
{
response = connection.sendNewAccountInfo(request);
}
ViewBag.AsIsResponse = response.response;
if (response.response.Contains("Duplicate"))
{
return(View("CreateAccount"));
}
return(View("Index"));
}
public async ValueTask <CreateAccountResponse> CadastrarNovaContaAsync(CreateAccountRequest request, Guid correlationId, CancellationToken ct)
{
CreateAccountResponse response;
string requestUri = $"{_urlBaseBolao}/account/signup";
string requestJson = JsonConvert.SerializeObject(request);
var content = new StringContent(requestJson, Encoding.UTF8, "application/json");
var httpResponse = await _bolaoHttpClient.PostAsync
(
requestUri,
content,
correlationId,
ct
);
var jsonResponse = await httpResponse.Content.ReadAsStringAsync();
if (httpResponse.StatusCode != HttpStatusCode.OK)
{
var errorsResponse = JsonConvert.DeserializeObject <IList <ErrorResponse> >(jsonResponse);
response = new CreateAccountResponse();
response.SetErrors(errorsResponse);
}
else
{
response = JsonConvert.DeserializeObject <CreateAccountResponse>(jsonResponse);
}
return(response);
}
public CreateAccountResponse Post([FromBody] CreateAccountRequest createAccountRequest)
{
var createAccountValidation = new CreateAccountValidation(new RepositoryFactory <AccountEntity>(),
_appSettings.Value.MongoConnectionString);
var createAccountValidationStatus = createAccountValidation.CreateAccount(
createAccountRequest.AccountName,
createAccountRequest.AccountPassword, createAccountRequest.Email);
if (createAccountValidationStatus.IsValid)
{
return new CreateAccountResponse
{
IsValid = createAccountValidationStatus.IsValid,
Message = createAccountValidationStatus.IsValid ? $@"{createAccountRequest.AccountName} has been created"
: $@"{createAccountRequest.AccountName} Already exists in Database"
}
}
;
return(new CreateAccountResponse
{
IsValid = false,
Message = $@"Could Not Add to Database because Account Name is already used"
});
}
public void Construct()
{
var action = new CreateAccountRequest(true, new[] { "mailto:[email protected]" }, false);
Assert.True(action.TermsOfServiceAgreed);
Assert.Equal("mailto:[email protected]", action.Contact[0]);
}
public ActionResult Register(string proposedUsername, string proposedPassword,
string proposedAddress, string proposedPhoneNumber, string proposedEmail, AccountType proposedType)
{
CreateAccount newAcc = new CreateAccount();
newAcc.username = proposedUsername;
newAcc.password = proposedPassword;
newAcc.address = proposedAddress;
newAcc.phonenumber = proposedPhoneNumber;
newAcc.email = proposedEmail;
newAcc.type = proposedType;
CreateAccountRequest CAR = new CreateAccountRequest(newAcc);
ServiceBusResponse response = ConnectionManager.sendNewAccountInfo(CAR);
if (!response.result)
{
ViewBag.createaccountresponse = "Error in creating account.\n" + response.response;
}
else
{
ViewBag.createaccountresponse = "New account successfully created. Successfully logged in!\n";
return(View("LoggedIn"));
}
return(View("CreateAccount"));
}
public async Task GivenValidRequestWhenAccountPostAsyncThenReturnCorrectValue()
{
var validRequest = new CreateAccountRequest
{
Id = _fixture.Create <long>(),
Name = _fixture.Create <string>(),
CreatedByUserId = _userId
};
var account = _fixture.Create <Account>();
var accountWrapper = new AccountWrapper(account);
_mapper
.Map <CreateAccountRequest, Account>(validRequest)
.Returns(account);
_userService
.CreateAccountAsync(_userId, account)
.Returns(accountWrapper);
var actual = await _userController.PostAsync(_userId, validRequest);
(actual.Result as StatusCodeResult)?
.StatusCode.Should()
.Be((int)HttpStatusCode.OK);
}
public AccountCreatedEvent(Guid id, CreateAccountRequest account) : base(nameof(AccountCreatedEvent), _eventVersion)
{
Id = id;
EventName = nameof(AccountCreatedEvent);
Account = account;
}
public async Task <Option <UserWithTokenResponse> > Register(RegisterRequest request)
{
using var client = new HttpClient();
var accountClient = new AccountClient(externals.Account, client);
var createAccount = new CreateAccountRequest
{
Username = request.Username,
EmailAddress = request.Email,
Password = request.Password,
};
Option <AccountWithTokenDto> response;
try
{
response = (await accountClient.AccountcommandCreateAsync(createAccount)).DeserializeOption();
}
catch (Exception e)
{
return(Option <UserWithTokenResponse> .FromError(e.Message));
}
return(response.Select(x => new UserWithTokenResponse
{
Id = x.Id,
Bio = x.Bio,
Username = x.Username,
Role = x.Role,
Token = x.Token,
}));
}
public CreateAccountResponse CreateAccount(CreateAccountRequest request)
{
var response = new CreateAccountResponse();
try
{
var propertyValues = new
{
Email = request.Email
};
response.ActivateAccountToken = WebSecurity.CreateUserAndAccount(request.UserName, request.Password, propertyValues, requireConfirmationToken: request.RequireActivation);
response.Success = true;
}
// https://msdn.microsoft.com/en-us/library/system.web.security.membershipcreateuserexception.statuscode(v=vs.110).aspx
catch (MembershipCreateUserException ex)
{
response.Message = this.GetErrorMessage(ex.StatusCode);
}
catch (Exception ex)
{
this.exceptionHandler.HandleException(ex);
response.Message = Resources.Common.InternalServerError;
}
return(response);
}
//public static Response CreateAccountRequestHandler(CreateAccountRequest arg)
//{
// Console.WriteLine("User " + arg.username + " attempted to create account.");
// User currentUser = new User(arg.username, arg.password);
// currentUser.equippedShip = new Cruiser();
// currentUser.equippedShip.ownerID = currentUser.id;
// currentUser.equippedShip.shipType = "Cruiser";
// StarDatabaseCode.InsertShip(currentUser.equippedShip, currentUser);
// StarDatabaseCode.SetProgramIDOfShip(currentUser.equippedShip);
public static Response CreateAccountRequestHandler(CreateAccountRequest arg)
{
Console.WriteLine("User " + arg.username + " attempted to create account.");
User currentUser = new User(arg.username, arg.password);
if (DatabaseFiles.DatabaseHandler.db.Query <User>($"SELECT * FROM users WHERE username='******'").ToList().Count > 0)
{
return(Response.From <User>(null));
}
else
{
currentUser.id = DatabaseFiles.DatabaseHandler.GetNumOfUsers() + 1;
var startSystem = DatabaseFiles.DatabaseHandler.db.Query <StarSystem>("SELECT * FROM starsystems WHERE ID=1").ToList()[0];
currentUser.position = startSystem;
currentUser.positionID = startSystem.ID;
currentUser.equippedShip = new Cruiser();
currentUser.equippedShip.shipType = "Cruiser";
currentUser.equippedShip.ownerID = currentUser.id;
currentUser.equippedShip.id = DatabaseFiles.DatabaseHandler.db.Query <BaseShip>("SELECT * FROM ships").ToList().Count() + 1;
currentUser.equippedShipID = currentUser.equippedShip.id;
BaseShip shipToReplace = new BaseShip(currentUser.equippedShip);
shipToReplace.ownerID = currentUser.id;
//shipToReplace.shipType = "Cruiser";
DatabaseFiles.DatabaseHandler.InsertShip(shipToReplace);
currentUser.seshID = CreateSessionID(currentUser.username + DateTime.Today.ToString(), DateTime.Now);
liveUsers.Add(currentUser.seshID, currentUser);
DatabaseFiles.DatabaseHandler.InsertUser(currentUser);
RequestListener.alerter.RegisterUser(currentUser);
return(Response.From(currentUser));
}
}
public IHttpActionResult RegisterNewUser([FromBody] UserRegistrationModel userRegistrationModel)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
CreateAccountRequest accountRequest;
try
{
accountRequest = new CreateAccountRequest(
userRegistrationModel.Password,
new MailAddress(userRegistrationModel.Mail));
}
catch (System.ArgumentException)
{
return(BadRequest("Fields must not be empty"));
}
int createdUserId;
try
{
createdUserId = _userManager.CreateUser(accountRequest);
}
catch (AccountAlreadyExistsException ex)
{
return(Content(HttpStatusCode.Conflict, ex.Message));
}
_mailingService.SetupEmailConfirmation(createdUserId);
return(Ok(createdUserId));
}
public void CreateAccount()
{
CreateAccountSample sample = new CreateAccountSample();
CreateAccountRequest requestCreateAccount = sample.CreateAccount();
Assert.IsNotNull(requestCreateAccount);
}
private async Task <Guid> CreateAccount(CreateAccountRequest request)
{
HttpResponseMessage createdAccount = await _client.PostAsync($"{ControllerUrl}",
GetHttpContentFromObj(request));
return(await GetObjFromHttpResponse <Guid>(createdAccount));
}
public ActionResult CreationConfirmationPage(string username, string email, string password,
string address, string phonenumber, AccountType users)
{
CreateAccount account = new CreateAccount();
account.username = username;
account.password = password;
account.address = address;
account.phonenumber = phonenumber;
account.email = email;
account.type = users;
CreateAccountRequest request = new CreateAccountRequest(account);
ServiceBusResponse response;
ServiceBusConnection connection = ConnectionManager.getConnectionObject(Globals.getUser());
if (connection == null)
{
response = ConnectionManager.sendNewAccountInfo(request);
}
else
{
response = connection.sendNewAccountInfo(request);
}
if (response.result)
{
return(View("Index"));
}
else
{
ViewBag.CreationMessage = response.response;
return(View("CreateAccount"));
}
}
internal virtual CreateAccountResponse CreateAccount(CreateAccountRequest request)
{
var marshaller = CreateAccountRequestMarshaller.Instance;
var unmarshaller = CreateAccountResponseUnmarshaller.Instance;
return(Invoke <CreateAccountRequest, CreateAccountResponse>(request, marshaller, unmarshaller));
}
public void should_validate_request()
{
var validator = new CreateAccountRequestValidator();
validator.ShouldHaveValidationErrorFor(x => x.Id, null as Guid?);
validator.ShouldHaveValidationErrorFor(x => x.Id, Guid.Empty);
validator.ShouldHaveValidationErrorFor(x => x.Name, null as AccountName);
var nameValidator = new AccountNameValidator();
nameValidator.ShouldHaveValidationErrorFor(x => x.Name, null as string);
nameValidator.ShouldHaveValidationErrorFor(x => x.Name, new string('a', AccountService.AccountName.MaxLength + 10));
nameValidator.ShouldHaveValidationErrorFor(x => x.Language, null as Language?);
nameValidator.ShouldHaveValidationErrorFor(x => x.Language, (Language)666);
var validRequest = new CreateAccountRequest
{
Id = Guid.NewGuid(),
Name = new AccountName
{
Name = "Bla",
Language = Language.Dutch
}
};
validator.ShouldNotHaveValidationErrorFor(x => x.Id, validRequest);
validator.ShouldNotHaveValidationErrorFor(x => x.Name, validRequest);
validator.ShouldNotHaveValidationErrorFor(x => x.Name.Name, validRequest);
validator.ShouldNotHaveValidationErrorFor(x => x.Name.Language, validRequest);
}
public ActionResult createAccountEntry(string username, string password, string address, string phonenumber, string email, string accountType)
{
var account = AccountType.notspecified;
switch (accountType)
{
case "user":
account = AccountType.user;
break;
case "business":
account = AccountType.business;
break;
}
phonenumber = phonenumber.Replace(" ", "").Replace("(", "").Replace(")", "").Replace("-", "");
CreateAccountRequest request = new CreateAccountRequest(new CreateAccount()
{
username = username,
password = password,
address = address,
email = email,
phonenumber = phonenumber,
type = account
});
ServiceBusResponse response = ConnectionManager.sendNewAccountInfo(request);
if (response.result)
{
ViewBag.CreateAccountResponse = "Account successfully created. You are now logged in";
}
return(View("CreateAccount"));
}
public CreateNewAccountPopup(CreateAccountRequest request)
{
InitializeComponent();
_responseHandler = request.ResponseHandler;
this.DataContext = this;
CreateAccountCommand = new DelegateCommand<object>(this.CreateAccountExecute, this.CanCreateAccountExecute);
CancelCommand = new DelegateCommand<object>(this.CancelExecute);
this.PropertyChanged += this.OnPropertyChanged;
this.Validate();
}
public async Task<HttpResponseMessage> CreateAccount(CreateAccountRequest request)
{
// Create storage client
using (var storageClient = new StorageManagementClient(new CertificateCloudCredentials(_subscriptionId, new X509Certificate2(
Convert.FromBase64String(_certificateBase64)))))
{
var response = await storageClient.StorageAccounts.CreateAsync(
new StorageAccountCreateParameters
{
AccountType = request.AccountType,
Location = request.Location,
Name = request.AccountName
});
return new HttpResponseMessage(response.HttpStatusCode);
}
}
public ActionResult Create(CreateAccountViewModel model)
{
if (this.ModelState.IsValid)
{
var request = new CreateAccountRequest
{
UserName = model.UserName,
Password = model.Password,
Email = model.Email,
FirstName = model.FirstName,
LastName = model.LastName
};
var response = this.accountService.CreateAccount(request);
if (response.Status == StatusCode.OK)
{
var messageResponse = this.SendActivateAccountToken(model.Email, response.ActivateAccountToken, model.FirstName, model.LastName);
if (messageResponse.Status == StatusCode.OK)
{
this.TempData["SuccessMessage"] = "You have successfully created a new account. An activation code has been sent to you by email. When you receive the this email, click on the link to activate your account.";
return this.RedirectToAction("LogIn");
}
else
{
this.ModelState.AddModelError(string.Empty, Resources.ErrorMessages.InternalServerError);
}
}
else if (response.Status == StatusCode.BadRequest)
{
this.ModelState.AddModelError(string.Empty, $"Your account was not created for the following reason: {this.GetErrorMessage(response.CreateAccountStatus)}");
}
else
{
this.ModelState.AddModelError(string.Empty, Resources.ErrorMessages.InternalServerError);
}
}
return this.View();
}
private void CreateAccountExecute(object dummyObject)
{
// Send CreateAccountRequestEvent to create the CreateNewAccount dialog
CreateAccountRequest request =
new CreateAccountRequest { ResponseHandler = CreateAccountResponseHandler };
_eventAggregator.GetEvent<CreateAccountRequestEvent>().Publish(request);
}
public void AccountCreateAccountRequestToJson()
{
CreateAccountRequest request = new CreateAccountRequest(Zencoder.BaseUrl)
{
AffiliateCode = "asdf1234",
Email = "*****@*****.**",
Newsletter = true,
Password = "******",
TermsOfService = true
};
Assert.AreEqual(
@"{""affiliate_code"":""asdf1234"",""email"":""*****@*****.**"",""newsletter"":""1"",""password"":""1234"",""terms_of_service"":""1""}",
request.ToJson());
}
/// <summary>
/// A non blocking create account request/response cycle.
/// </summary>
/// <param name="email">The email address to create the account with.</param>
/// <param name="password">The password to create the account with.</param>
/// <param name="affiliateCode">The affiliate code to create the account with, if applicable.</param>
/// <param name="termsOfService">A value indicating whether the terms of service are agreed to.</param>
/// <param name="newsletter">A value indicating whether to subscribe the email address to the newsletter.</param>
/// <param name="baseUrl">The service base URL.</param>
/// <param name="callback">The call response.</param>
public static void CreateAccount(string email, string password, string affiliateCode, bool? termsOfService, bool? newsletter, Uri baseUrl, Action<CreateAccountResponse> callback)
{
CreateAccountRequest request = new CreateAccountRequest(baseUrl)
{
AffiliateCode = affiliateCode,
Email = email,
Newsletter = newsletter,
Password = password,
TermsOfService = termsOfService,
};
request.GetResponseAsync(callback);
}
/// <summary>
/// A blocking create account request/response cycle.
/// </summary>
/// <param name="email">The email address to create the account with.</param>
/// <param name="password">The password to create the account with.</param>
/// <param name="affiliateCode">The affiliate code to create the account with, if applicable.</param>
/// <param name="termsOfService">A value indicating whether the terms of service are agreed to.</param>
/// <param name="newsletter">A value indicating whether to subscribe the email address to the newsletter.</param>
/// <param name="baseUrl">The service base URL.</param>
/// <returns>The call response.</returns>
public static CreateAccountResponse CreateAccount(string email, string password, string affiliateCode, bool? termsOfService, bool? newsletter, Uri baseUrl)
{
CreateAccountRequest request = new CreateAccountRequest(baseUrl)
{
AffiliateCode = affiliateCode,
Email = email,
Newsletter = newsletter,
Password = password,
TermsOfService = termsOfService
};
return request.GetResponse();
}
public CreateAccountResponse CreateAccount(CreateAccountRequest request)
{
var response = new CreateAccountResponse();
try
{
var propertyValues = new
{
Email = request.Email
};
response.ActivateAccountToken = WebSecurity.CreateUserAndAccount(request.UserName, request.Password, propertyValues, requireConfirmationToken: request.RequireActivation);
response.Status = StatusCode.OK;
}
// https://msdn.microsoft.com/en-us/library/system.web.security.membershipcreateuserexception.statuscode(v=vs.110).aspx
catch (MembershipCreateUserException ex)
{
response.Status = StatusCode.BadRequest;
response.CreateAccountStatus = this.MapCreateAccountStatus(ex.StatusCode);
}
catch (Exception ex)
{
response.Status = StatusCode.InternalServerError;
this.exceptionHandler.HandleException(ex);
}
return response;
}
private void OnCreateAccountRequest(CreateAccountRequest request)
{
CreateNewAccountPopup popup = new CreateNewAccountPopup(request);
popup.Show();
}
