private static void CreateUser(String User, String Path)
{
if (String.IsNullOrEmpty(Token))
{
stsClient = new AmazonIdentityManagementServiceClient(AccessKeyId, SecretKey, iamconfig);
}
else
{
stsClient = new AmazonIdentityManagementServiceClient(AccessKeyId, SecretKey, Token, iamconfig);
}
CreateUserRequest req = new CreateUserRequest(User);
if (!String.IsNullOrEmpty(Path))
{
req.Path = Path;
}
try
{
CreateUserResponse response = stsClient.CreateUser(req);
Console.WriteLine("User created");
}
catch (Exception ex)
{
Console.WriteLine("Error occured while creating user. " + ex.ToString());
}
}
public CreateUserResponse CreatUser(CreateUserRequest request)
{
string encryptedPassword = HashPassword(request.User.Password);
var response = new CreateUserResponse();
var dbUser = new UserEntity
{
FirstName = request.User.FirstName,
LastName = request.User.LastName,
Email = request.User.Email,
Password = encryptedPassword,
Username = request.User.UserName
};
try
{
uow.Repository <UserEntity>().Add(dbUser);
uow.Save();
response.Success = true;
response.UserId = dbUser.UserId;
}
catch (Exception ex)
{
response.ErrorMessage = ex.Message;
response.Success = false;
}
return(response);
}
private IEnumerator CreateUserRoutine(string url, Action <CreateUserResponse> callback = null)
{
string bodyJsonString = "{\"devicetype\": \"my_hue_app#mydevice_local\"}";
var request = new UnityWebRequest(url, "POST");
byte[] bodyRaw = Encoding.UTF8.GetBytes(bodyJsonString);
request.uploadHandler = (UploadHandler) new UploadHandlerRaw(bodyRaw);
request.downloadHandler = (DownloadHandler) new DownloadHandlerBuffer();
request.SetRequestHeader("Content-Type", "application/json");
yield return(request.SendWebRequest());
Debug.Log("Status Code: " + request.responseCode);
Debug.Log("response: " + request.downloadHandler.text);
CreateUserResponse response = null;
if (!CreateUserResponse.CreateFromJSON(request.downloadHandler.text, out response))
{
Debug.Log("Data not in JSON format");
//Nothing more as I create the object and fill in the details.
//But you could like adding some extra processing in your own code
}
if (callback != null)
{
callback(response);
}
}
public void CreateUserClick()
{
Debug.Log("Create user clicked.");
User user = new User();
user.username = usernameText.text;
user.password = passwordText.text;
string url = RestUtil.LOGIN_SERVICE_URI + "create";
string jsonData = JsonUtility.ToJson(user);
Debug.Log("Sending jsonData: " + jsonData + " to " + url);
responseText = RestUtil.Instance.Post(url, jsonData).text;
CreateUserResponse response = JsonUtility.FromJson <CreateUserResponse>(responseText);
if (response != null && response.status == "DUPLICATE")
{
errorText.text = "The username" + response.user + " is already in use. Please pick a different username.";
errorPanel.SetActive(true);
}
else if (response != null && response.status == "SUCCESS")
{
errorText.text = "User " + response.user + " successfully created! Please sign in now to play.";
errorPanel.SetActive(true);
}
else
{
errorText.text = "An error occurred when trying to create a new user. Please try again in a few minutes.";
errorPanel.SetActive(true);
}
}
public async Task <CreateUserResponse> CreateUserAsync(CreateUserRequest request)
{
var response = new CreateUserResponse();
//request.UserModel.Password = request.UserModel.Password.Hash(HashType.SHA256);
bool isExists =
await _userRepository.IsExistsUserAsync(request.UserModel.Username, request.UserModel.EmailAddress);
if (!isExists)
{
//TODO: Create User
var userEntity = _userMapper.ToEntity(request.UserModel);
userEntity.UserGroupId = 1;
userEntity = await _userRepository.AddAsync(userEntity);
if (userEntity != null && userEntity.Id != Guid.Empty)
{
response.StatusCode = (int)HttpStatusCode.Created;
return(response);
}
//TODO: Add Logging
_logger.LogWarning("");
}
response.StatusCode = (int)HttpStatusCode.InternalServerError;
return(response);
}
public async Task <CreateUserResponse> Create(string email, string userName, string password)
{
var applicationUser = new ApplicationUser
{
Email = email,
UserName = userName,
};
var identityResult = await this.userManager.CreateAsync(applicationUser, password);
if (identityResult.Succeeded)
{
var user = new User(applicationUser.Id, userName, email);
this.dbContext.Users.Add(user);
await this.dbContext.SaveInfoAndChangesAsync();
var response = new CreateUserResponse(applicationUser.Id, true);
return(response);
}
else
{
var response = new CreateUserResponse(applicationUser.Id, false,
identityResult.Errors.Select(x => new Error(x.Code, x.Description)));
return(response);
}
}
public ActionResult <CreateUserService> Post(UserRequest request)
{
CreateUserService _service = new CreateUserService(_unitOfWork);
CreateUserResponse response = _service.Execute(request);
return(Ok(response));
}
public async Task <CreateUserResponse> CreateUser(string userIdentifier, string password, string location, string createdBy)
{
var reply = new CreateUserResponse()
{
IsSuccessful = false,
Result = CreateUserResult.CREATE_OTHER_FAILURE
};
using (IdentityProviderContext context = IdentityProviderContext.Create(connectionString))
{
try
{
var user = new User(createdBy, userIdentifier, password);
context.Users.Add(user);
await context.SaveChangesAsync();
reply.Result = CreateUserResult.CREATE_SUCCESS;
reply.IsSuccessful = true;
}
catch (Exception e)
{
reply.Result = CreateUserResult.CREATE_DATABASE_FAILURE;
reply.IsSuccessful = false;
}
}
return(reply);
}
public override AmazonWebServiceResponse Unmarshall(XmlUnmarshallerContext context)
{
CreateUserResponse response = new CreateUserResponse();
context.Read();
int targetDepth = context.CurrentDepth;
while (context.ReadAtDepth(targetDepth))
{
if (context.IsStartElement)
{
if (context.TestExpression("CreateUserResult", 2))
{
UnmarshallResult(context, response);
continue;
}
if (context.TestExpression("ResponseMetadata", 2))
{
response.ResponseMetadata = ResponseMetadataUnmarshaller.Instance.Unmarshall(context);
}
}
}
return(response);
}
/// <summary>
/// This method creates a new IAM user.
/// </summary>
/// <param name="client">The IAM client object.</param>
/// <param name="request">The user creation request.</param>
/// <returns>The object returned by the call to CreateUserAsync.</returns>
public static async Task <User> CreateNewUserAsync(AmazonIdentityManagementServiceClient client, CreateUserRequest request)
{
CreateUserResponse response = null;
try
{
response = await client.CreateUserAsync(request);
// Show the information about the user from the response.
Console.WriteLine("\n--------------------------------------------------------------------------------------------------------------");
Console.WriteLine($"New user: {response.User.UserName} ARN = {response.User.Arn}.");
Console.WriteLine($"{response.User.UserName} has {response.User.PermissionsBoundary}.");
}
catch (EntityAlreadyExistsException ex)
{
Console.WriteLine($"{ex.Message}");
}
if (response is not null)
{
return(response.User);
}
else
{
return(null);
}
}
public CreateUserResponse CreateUser(string username, string password, string email)
{
var user = new DAL.Entities.User
{
UserName = username,
PasswordHash = GetPasswordHash(password),
Email = email
};
var createUserResponse = new CreateUserResponse();
if (_context.Users.Any(u => u.UserName == username))
{
createUserResponse.Success = false;
createUserResponse.Message = "Username already taken.";
return(createUserResponse);
}
if (_context.Users.Any(u => u.Email == email))
{
createUserResponse.Success = false;
createUserResponse.Message = "Email already taken.";
return(createUserResponse);
}
_context.Users.Add(user);
_context.SaveChanges();
createUserResponse.Success = true;
createUserResponse.Message = $"Successfully created user {user.UserName}.";
return(createUserResponse);
}
void HandleCreateAccountResponse(CreateUserResponse response)
{
createAccount.Invoke(new Action(() =>
{
createAccount.HandleCreateAccountResponse(response.Payload);
}));
}
public void TestCreateGetUser()
{
string username = "******" + DateTime.Now.Ticks;
try
{
CreateUserRequest request = new CreateUserRequest()
{
UserName = username, Path = IAMUtil.TEST_PATH
};
CreateUserResponse response = Client.CreateUser(request);
Assert.AreEqual(username, response.User.UserName);
GetUserResponse getResponse = Client.GetUser(new GetUserRequest()
{
UserName = username
});
Assert.AreEqual(username, getResponse.User.UserName);
Assert.AreNotEqual(DateTime.MinValue, getResponse.User.CreateDate);
}
finally
{
Client.DeleteUser(new DeleteUserRequest()
{
UserName = username
});
}
}
/// <summary>
/// Creates the user.
/// </summary>
/// <param name="createUserRequest">The create user request.</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <returns></returns>
/// <exception cref="Exception">Http Status Code [{response.StatusCode}] Message [{responseBody}]</exception>
private async Task <CreateUserResponse> CreateUser(CreateUserRequest createUserRequest,
CancellationToken cancellationToken)
{
CreateUserResponse createUserResponse = await this.TestingContext.DockerHelper.SecurityServiceClient.CreateUser(createUserRequest, cancellationToken).ConfigureAwait(false);
return(createUserResponse);
}
public async Task <CreateUserResponse> CreateAsync(string firstName, string lastName, string email, string password)
{
var response = new CreateUserResponse();
var appUser = new AppUser {
Email = email, UserName = email
};
var identityResult = await _userManager.CreateAsync(appUser, password);
if (!identityResult.Succeeded)
{
response.IsSuccess = false;
response.Errors = new List <Exception>();
foreach (var error in identityResult.Errors)
{
response.Errors.Add(new UserExceptionCreate(error.Description));
}
return(response);
}
var user = new User(firstName, lastName, appUser.Id, appUser.UserName);
_database.Users.Add(user);
_database.Save();
response.IsSuccess = true;
return(response);
}
private static void UnmarshallResult(XmlUnmarshallerContext context, CreateUserResponse response)
{
int originalDepth = context.CurrentDepth;
int targetDepth = originalDepth + 1;
if (context.IsStartOfDocument)
{
targetDepth += 2;
}
while (context.ReadAtDepth(originalDepth))
{
if (context.IsStartElement || context.IsAttribute)
{
if (context.TestExpression("User", targetDepth))
{
var unmarshaller = UserUnmarshaller.Instance;
response.User = unmarshaller.Unmarshall(context);
continue;
}
}
}
return;
}
/// <summary>
/// Unmarshaller the response from the service to the response class.
/// </summary>
/// <param name="context"></param>
/// <returns></returns>
public override AmazonWebServiceResponse Unmarshall(JsonUnmarshallerContext context)
{
CreateUserResponse response = new CreateUserResponse();
context.Read();
int targetDepth = context.CurrentDepth;
while (context.ReadAtDepth(targetDepth))
{
if (context.TestExpression("ServerId", targetDepth))
{
var unmarshaller = StringUnmarshaller.Instance;
response.ServerId = unmarshaller.Unmarshall(context);
continue;
}
if (context.TestExpression("UserName", targetDepth))
{
var unmarshaller = StringUnmarshaller.Instance;
response.UserName = unmarshaller.Unmarshall(context);
continue;
}
}
return(response);
}
public CreateUserResponse CreateUser(CreateUserRequest request)
{
CreateUserResponse response = new CreateUserResponse();
try
{
User user = request.ConvertToUser();
List <User> users = userRepository.ReadAll();
if (users.Where(x => x.Username == user.Username).Count() > 0)
{
throw new Exception("Korisnik sa datim korisničkim imenom već postoji u bazi!");
}
if (users.Where(x => x.Password == user.Password).Count() > 0)
{
throw new Exception("Korisnik sa datim email-om već postoji u bazi!");
}
userRepository.Create(user);
response.Success = true;
}
catch (Exception ex)
{
response.Message = ex.Message;
response.Success = false;
}
return(response);
}
/**
* Create a new user
* with the provided name.
*/
public async Task <CreateUserResponse> CreateUser(CreateUserRequest payload)
{
try
{
var response = new CreateUserResponse();
var user = new User()
{
id = Guid.NewGuid(),
name = payload.name,
socketId = payload.socketId
};
bool result = await _userRepository.Save(user);
if (!result)
{
throw new ApplicationError("[UserService.CreateUser]", 3);
}
response.id = user.id;
response.name = user.name;
await _unitOfWork.Save();
return(response);
}
catch (Exception e)
{
throw e;
}
}
public static CreateUserResponse Unmarshall(UnmarshallerContext _ctx)
{
CreateUserResponse createUserResponse = new CreateUserResponse();
createUserResponse.HttpResponse = _ctx.HttpResponse;
createUserResponse.Code = _ctx.StringValue("CreateUser.Code");
createUserResponse.HttpStatusCode = _ctx.IntegerValue("CreateUser.HttpStatusCode");
createUserResponse.Message = _ctx.StringValue("CreateUser.Message");
createUserResponse.RequestId = _ctx.StringValue("CreateUser.RequestId");
List <string> createUserResponse_params = new List <string>();
for (int i = 0; i < _ctx.Length("CreateUser.Params.Length"); i++)
{
createUserResponse_params.Add(_ctx.StringValue("CreateUser.Params[" + i + "]"));
}
createUserResponse._Params = createUserResponse_params;
CreateUserResponse.CreateUser_Data data = new CreateUserResponse.CreateUser_Data();
data.DisplayName = _ctx.StringValue("CreateUser.Data.DisplayName");
data.Email = _ctx.StringValue("CreateUser.Data.Email");
data.Extension = _ctx.StringValue("CreateUser.Data.Extension");
data.LoginName = _ctx.StringValue("CreateUser.Data.LoginName");
data.Mobile = _ctx.StringValue("CreateUser.Data.Mobile");
data.UserId = _ctx.StringValue("CreateUser.Data.UserId");
data.WorkMode = _ctx.StringValue("CreateUser.Data.WorkMode");
createUserResponse.Data = data;
return(createUserResponse);
}
/// <summary>
/// Unmarshaller the response from the service to the response class.
/// </summary>
/// <param name="context"></param>
/// <returns></returns>
public override AmazonWebServiceResponse Unmarshall(JsonUnmarshallerContext context)
{
CreateUserResponse response = new CreateUserResponse();
return(response);
}
public static CreateUserResponse Unmarshall(UnmarshallerContext context)
{
CreateUserResponse createUserResponse = new CreateUserResponse();
createUserResponse.HttpResponse = context.HttpResponse;
createUserResponse.Code = context.StringValue("CreateUser.Code");
createUserResponse.Message = context.StringValue("CreateUser.Message");
createUserResponse.RequestId = context.StringValue("CreateUser.RequestId");
CreateUserResponse.CreateUser_Data data = new CreateUserResponse.CreateUser_Data();
data.UserId = context.IntegerValue("CreateUser.Data.UserId");
data.IsvSubId = context.StringValue("CreateUser.Data.IsvSubId");
data.UserName = context.StringValue("CreateUser.Data.UserName");
data.UserGroupId = context.IntegerValue("CreateUser.Data.UserGroupId");
data.IdNumber = context.StringValue("CreateUser.Data.IdNumber");
data.FaceImageUrl = context.StringValue("CreateUser.Data.FaceImageUrl");
data.Address = context.StringValue("CreateUser.Data.Address");
data.Age = context.StringValue("CreateUser.Data.Age");
data.Gender = context.StringValue("CreateUser.Data.Gender");
data.PlateNo = context.StringValue("CreateUser.Data.PlateNo");
data.PhoneNo = context.StringValue("CreateUser.Data.PhoneNo");
data.Attachment = context.StringValue("CreateUser.Data.Attachment");
data.BizId = context.StringValue("CreateUser.Data.BizId");
createUserResponse.Data = data;
return(createUserResponse);
}
/// <summary>
/// Creates the user.
/// </summary>
/// <param name="createUserRequest">The create user request.</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <returns></returns>
public async Task <CreateUserResponse> CreateUser(CreateUserRequest createUserRequest,
CancellationToken cancellationToken)
{
CreateUserResponse response = null;
String requestUri = this.BuildRequestUrl("/api/users");
try
{
String requestSerialised = JsonConvert.SerializeObject(createUserRequest);
StringContent httpContent = new StringContent(requestSerialised, Encoding.UTF8, "application/json");
// Add the access token to the client headers
//this.HttpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", accessToken);
// Make the Http Call here
HttpResponseMessage httpResponse = await this.HttpClient.PostAsync(requestUri, httpContent, cancellationToken);
// Process the response
String content = await this.HandleResponse(httpResponse, cancellationToken);
// call was successful so now deserialise the body to the response object
response = JsonConvert.DeserializeObject <CreateUserResponse>(content);
}
catch (Exception ex)
{
// An exception has occurred, add some additional information to the message
Exception exception = new Exception($"Error creating user {createUserRequest.EmailAddress}.", ex);
throw exception;
}
return(response);
}
private void CreateUser()
{
try
{
// get the session from the PrivateAuthentication class
using (var session = TestBase.PrivateAuthentication.GetPrivateSession(AuthenticationInfoProvider.Current.DefaultCompanyName,
AuthenticationInfoProvider.Current.DefaultUserLogin,
AuthenticationInfoProvider.Current.DefaultUserPassword))
{
var request = CreateUserRequest.Builder()
.AddName(string.Format("Test User {0}", Util.GetUniqueString(32, false)))
.AddUsername("testuser")
.AddLanguage("en_us")
.AddDeptId(1001)
.AddMobile("0909686767")
.AddMobileMail(string.Format("name{0}@yahoo.com", Util.GetUniqueString(32, false)))
.AddApprovalFlg(false)
.AddTimeZone("Asia/Saigon")
.AddEndDate(DateTime.Now.AddDays(1))
.AddNewsMailFlg(true)
.AddAdminNewsMailFlg(false)
.AddStartDate(DateTime.Now)
.AddMail(string.Format("name{0}@yahoo.com", Util.GetUniqueString(32, false)));
CreateUserResponse response = session.Call(request.Build());
Assume.That(response.Id, Is.Not.Null.And.GreaterThan(0), "Can not add new user into company!");
validUserId = response.Id;
}
}
catch (Exception ex)
{
TestContext.Out.WriteLine("Exception: {0}", ex.Message);
Assume.That(false, "Could not create a user!");
}
}
public void CreateUser()
{
CreateUserRequest request = new CreateUserRequest(connection, testToken);
request.Email = "*****@*****.**";
request.FirstName = "Knar";
request.LastName = "Lhe";
request.Nicknane = "Knar666";
request.Password = "******";
KeyVaultClient KeyVault;
try
{
var azureServiceTokenProvider = new AzureServiceTokenProvider();
var _token = azureServiceTokenProvider.GetAccessTokenAsync("https://vault.azure.net").Result;
KeyVault = new KeyVaultClient(new KeyVaultClient.AuthenticationCallback(azureServiceTokenProvider.KeyVaultTokenCallback));
}
catch (Exception e)
{
throw e;
}
var bundle = KeyVault.GetSecretAsync("https://pr-kv-uks-dev.vault.azure.net/secrets/AppConnectionKey").Result;
request.AppAccessToken = bundle.Value;
CreateUserResponse response = request.Send();
Assert.AreEqual(response.StatusCode, System.Net.HttpStatusCode.OK);
}
// User Management Functions //
public CreateUserResponse CreateUser(string login, string password, string email, string firstName, string middleName, string lastName)
{
// Generate UUID for user //
Guid uuid = System.Guid.NewGuid();
// Create hash for users password //
string hash = Hashing.GenerateHash(password);
using (var connection = new SqlConnection(_connectionString))
{
connection.Open();
CreateUserResponse crResponse = new CreateUserResponse
{
User = null,
Success = false
};
crResponse.User = connection
.Query <User>(
"EXEC [Support-API].[dbo].[SP_Create_User] @UUID = @UUID, @Login = @Login, @Hash = @Hash, @Email = @Email, @First_Name = @First_Name, @Middle_Name = @Middle_Name, @Last_Name = @Last_Name",
new { UUID = uuid.ToString(), Login = login, Hash = hash, Email = email, First_Name = firstName, Middle_Name = middleName, Last_Name = lastName }
).FirstOrDefault();
if (crResponse.User != null)
{
crResponse.Success = true;
}
return(crResponse);
}
}
public ActionResult <Response> Create([FromBody] CreateUserRequest model)
{
var identity = (ClaimsIdentity)HttpContext.User.Identity;
_unitOfWork.SetIdentity(identity);
var user = new User()
{
Role = model.Role,
Username = model.Username,
Password = _authService.HashPassword(model.Password, out byte[] salt),
Salt = Convert.ToBase64String(salt),
};
_unitOfWork.UserRepository.Add(user);
_unitOfWork.SaveChanges();
user = _unitOfWork.UserRepository.GetSingle(user.Id, x => x.Include(i => i.RoleNavigation));
var data = new CreateUserResponse()
{
Id = user.Id,
Username = user.Username,
Role = user.RoleNavigation.Code,
};
return(Ok(new Response(HttpStatusCode.OK, data)));
}
public CreateUserResponse ResetPassword([FromBody] ResetPasswordRequest pwResetRequest)
{
CreateUserResponse response = new CreateUserResponse();
if (string.IsNullOrEmpty(pwResetRequest.User.Email) ||
string.IsNullOrEmpty(pwResetRequest.User.Password) ||
string.IsNullOrEmpty(pwResetRequest.Token))
{
response.Error = "Missing necessary data";
}
User user = pwResetRequest.User;
using (RequestTracker request = new RequestTracker(Constant.RequestAPI.ResetPW.ToString(), user.Email))
{
try
{
user.Init();
if (string.IsNullOrEmpty(user.Password) || user.Password.Length < 8)
{
request.response = RequestTracker.RequestResponse.UserError;
response.Error = "Password must be at least 8 characters";
return(response);
}
User retrievedUser;
TableStore.Get <User>(TableStore.TableName.users, user.PartitionKey, user.Email, out retrievedUser);
if (retrievedUser == null)
{
request.response = RequestTracker.RequestResponse.UserError;
response.Error = "Invalid user";
return(response);
}
// Confirm token
if (retrievedUser.PWResetTokenWithExpiry == null ||
retrievedUser.PWResetTokenWithExpiry.Item1 != pwResetRequest.Token ||
DateTime.Compare(DateTime.UtcNow, retrievedUser.PWResetTokenWithExpiry.Item2) > 0)
{
request.response = RequestTracker.RequestResponse.UserError;
response.Error = "Invalid or expired token";
return(response);
}
retrievedUser.Password = user.Password;
retrievedUser.EncryptPassword();
retrievedUser.PWResetTokenWithExpiry = null;
retrievedUser.ClearAuthTokens();
string token = retrievedUser.GetAuthToken();
TableStore.Update(TableStore.TableName.users, retrievedUser);
response.Token = token;
response.Error = "Success";
return(response);
}
catch (Exception e)
{
request.response = RequestTracker.RequestResponse.ServerError;
ExceptionTracker.LogException(e);
response.Error = "Oops, something went wrong. Initiating developer punishment.";
return(response);
}
}
}
public void Handle(CreateUserResponse message)
{
Console.WriteLine("reply received from createuserhandler " + this.Data.Name);
this.MarkAsComplete();
}
public CreateUserResponse CreateAccount(Patient patient)
{
CreateUserResponse response = new CreateUserResponse();
Account account;
AccountBO registrationBO = new AccountBO();
account = registrationBO.CreateAccount(patient);
response.account = account;
return response;
}
public async Task <CreateUserResponse> CreateUser(CreateUserRequest o)
{
var result = new CreateUserResponse(o.RequestId);
result.Application = o.Application;
result.Id = await Server.CreateUser(o.Application, o.Username, o.Password, o.FirstName, o.LastName, o.Email, o.Phone);
return(result);
}
public CreateUserResponse CreateUser(CreateUserRequest request)
{
CreateUserResponse response = new CreateUserResponse();
AuthToken authToken = null;
try
{
Common.Helpers.ValidationHelper.ValidateRequiredField(request.AuthToken, "Auth Token");
Common.Helpers.ValidationHelper.ValidateRequiredField(request.AntiForgeryToken, "Anti Forgery Token");
Common.Helpers.ValidationHelper.ValidateRequiredField(request.FirstName, "First Name");
Common.Helpers.ValidationHelper.ValidateRequiredField(request.LastName, "Last Name");
Common.Helpers.ValidationHelper.ValidateRequiredField(request.Username, "User Name");
Common.Helpers.ValidationHelper.ValidateRequiredField(request.EmailAddress, "Email Address");
Common.Helpers.ValidationHelper.ValidateRequiredField(request.Password, "Password");
Common.Helpers.ValidationHelper.ValidateUsername(request.Username);
Common.Helpers.ValidationHelper.ValidateStringLength(request.FirstName, "First Name", Constants.MaxNameLength);
Common.Helpers.ValidationHelper.ValidateStringLength(request.LastName, "Last Name", Constants.MaxNameLength);
Common.Helpers.ValidationHelper.ValidateMinStringLength(request.Username, "User Name", Constants.MinUsernameLength);
Common.Helpers.ValidationHelper.ValidateStringLength(request.Username, "User Name", Constants.MaxUsernameLength);
Common.Helpers.ValidationHelper.ValidateStringLength(request.EmailAddress, "Email Address", Constants.MaxUsernameLength);
Common.Helpers.ValidationHelper.ValidateStringLength(request.Password, "Password", Constants.MaxPasswordLength);
Common.Helpers.ValidationHelper.ValidateEmailAddress(request.EmailAddress);
ValidationHelper.ValidatePassword(request.Password);
if (!UserController.ValidateSession(request.AuthToken, out authToken))
{
throw new AuthenticationException("Authentication failed.");
}
UserController.ValidateAntiForgeryToken(request.AntiForgeryToken, authToken);
UserController.CreateUser(request.Username, request.Password, request.EmailAddress, request.FirstName, request.LastName, authToken, false);
}
catch (AuthenticationException ex)
{
throw new WebFaultException<string>(ex.Message, System.Net.HttpStatusCode.BadRequest);
}
catch (Common.Exceptions.ValidationException ex)
{
throw new WebFaultException<string>(ex.Message, System.Net.HttpStatusCode.BadRequest);
}
catch (Exception ex)
{
ExceptionHelper.Log(ex, authToken == null ? null : authToken.Username);
throw new WebFaultException<string>("An unknown error has occurred.", System.Net.HttpStatusCode.InternalServerError);
}
return response;
}
/// <summary>
/// Creates the user.
/// </summary>
/// <param name="newUser">The new user.</param>
/// <returns>
/// User entity, Contain validation result message if any.
/// </returns>
public CreateUserResponse CreateUser(User newUser)
{
IEnumerable<ValidationMessage> validationResult = ValidateUser(newUser).ToList();
if (!validationResult.HasError())
{
_userRepository.Create(newUser);
}
var response = new CreateUserResponse {User = newUser};
response.ValidationMessages.AddValidationMessages(validationResult);
return response;
}
public static void HandleMessage(Byte[] msgData, GameSession session, GamePlayer client)
{
using(MemoryStream stream = new MemoryStream(msgData))
{
BaseMessage msg = Serializer.Deserialize<BaseMessage>(stream);
switch((MessageType)msg.messageType)
{
case MessageType.LoginRequest:
{
LoginRequest loginMsg = (LoginRequest) msg;
int status = LoginManager.GetInstance().ValidateCredentials(new User.GCUser.LoginInfo(loginMsg.username), loginMsg.password);
LoginResponse response = new LoginResponse() { success = (status == 0) };
client.DispatchMessage(response);
break;
}
case MessageType.ChatMessage:
{
session.SendToPlayers(msgData);
break;
}
case MessageType.CreateUserRequest:
{
CreateUserRequest createUserMessage = (CreateUserRequest)msg;
int status = (int)DBEnum.DBResponseCodes.SUCCESS;//LoginManager.GetInstance().CreateUser(new User.GCUser.LoginInfo(createUserMessage.mUsername), createUserMessage.mPassword);
CreateUserResponse response = new CreateUserResponse() { success = ((int)DBEnum.DBResponseCodes.SUCCESS == status) };
client.DispatchMessage(response);
break;
}
case MessageType.Heartbeat:
default:
{
break;
}
}
}
}
public CreateUserResponse Create(CreateUserRequest request)
{
var response = new CreateUserResponse();
try
{
var user = request.MapTo<User>();
user.Role = DataContext.RoleGroups.First(x => x.Id == request.RoleId);
user.PasswordSalt = crypto.GenerateSalt(crypto.HashIterations,crypto.SaltSize);
user.Password = crypto.Compute(request.Password, user.PasswordSalt);
//user.Password = _pass.HashPassword(request.Password);
DataContext.Users.Add(user);
DataContext.SaveChanges();
response.IsSuccess = true;
response.Message = "User item has been added successfully";
}
catch (DbUpdateException dbUpdateException)
{
response.Message = dbUpdateException.Message;
}
return response;
}
public CreateUserResponse CreateUser(CreateUserRequest request)
{
var response = new CreateUserResponse();
try
{
var user = request.User;
var password = request.Password ?? Membership.GeneratePassword(14, 5);
var now = DateTimeOffset.Now;
var propertyValues = new
{
FirstName = user.FirstName.Trim(),
LastName = user.LastName.Trim(),
Email = user.Email.Trim().ToLower(),
Created = now,
Updated = now
};
WebSecurity.CreateUserAndAccount(user.UserName.Trim(), password, propertyValues, requireConfirmationToken: false);
response.Password = password;
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;
}
