public void Parse_Returns_Expected_Data_When_User_Exists(string username, UserStatus status, int averageSpeed, long downloadCount, int fileCount, int directoryCount, string countryCode)
{
var msg = new MessageBuilder()
.WriteCode(MessageCode.Server.AddUser)
.WriteString(username)
.WriteByte(1) // exists = true
.WriteInteger((int)status)
.WriteInteger(averageSpeed)
.WriteLong(downloadCount)
.WriteInteger(fileCount)
.WriteInteger(directoryCount)
.WriteString(countryCode)
.Build();
var r = AddUserResponse.Parse(msg);
Assert.Equal(username, r.Username);
Assert.True(r.Exists);
Assert.Equal(status, r.Status);
Assert.Equal(averageSpeed, r.AverageSpeed);
Assert.Equal(downloadCount, r.DownloadCount);
Assert.Equal(fileCount, r.FileCount);
Assert.Equal(directoryCount, r.DirectoryCount);
Assert.Equal(countryCode, r.CountryCode);
}
public void Parse_Does_Not_Throw_If_CountryCode_Is_Blank(string username, UserData userData)
{
var msg = new MessageBuilder()
.WriteCode(MessageCode.Server.AddUser)
.WriteString(username)
.WriteByte(1) // exists = true
.WriteInteger((int)userData.Status)
.WriteInteger(userData.AverageSpeed)
.WriteLong(userData.UploadCount)
.WriteInteger(userData.FileCount)
.WriteInteger(userData.DirectoryCount)
.WriteString(string.Empty)
.Build();
var r = AddUserResponse.FromByteArray(msg);
Assert.Equal(username, r.Username);
Assert.True(r.Exists);
Assert.Equal(userData.Status, r.UserData.Status);
Assert.Equal(userData.AverageSpeed, r.UserData.AverageSpeed);
Assert.Equal(userData.UploadCount, r.UserData.UploadCount);
Assert.Equal(userData.FileCount, r.UserData.FileCount);
Assert.Equal(userData.DirectoryCount, r.UserData.DirectoryCount);
Assert.Empty(r.UserData.CountryCode);
}
private async Task <bool> AddUserAppAsync(SetUserRequest request)
{
try
{
AddUserResponse _response = new AddUserResponse();
ApplicationUser appUser = new ApplicationUser()
{
UserName = request.email,
Email = request.email
};
var result = await _userManager.CreateAsync(appUser, GeneraPws(request.email));
if (result.Succeeded)
{
//var bRolUser = await AssignUserRole(appUser, request.ID_Rol);
return(true);
}
return(false);
}
catch (CError e)
{
var jsonModel = JsonConvert.SerializeObject(request);
throw _errorManager.AddError("Error Generico", "AddUserApp", e, MethodBase.GetCurrentMethod(), jsonModel);
}
catch (System.Exception ex)
{
var jsonModel = JsonConvert.SerializeObject(request);
throw _errorManager.AddError("Error Generico", "AddUserApp", ex, MethodBase.GetCurrentMethod(), jsonModel);
}
}
public async Task AddUserAsyncAsync_Throws_SoulseekClientException_On_Throw(string username, bool exists, UserData userData)
{
var result = new AddUserResponse(username, exists, userData);
var waiter = new Mock <IWaiter>();
waiter.Setup(m => m.Wait <AddUserResponse>(It.IsAny <WaitKey>(), null, It.IsAny <CancellationToken>()))
.Returns(Task.FromResult(result));
var serverConn = new Mock <IMessageConnection>();
serverConn.Setup(m => m.WriteAsync(It.IsAny <IOutgoingMessage>(), It.IsAny <CancellationToken>()))
.Throws(new ConnectionException("foo"));
using (var s = new SoulseekClient(waiter: waiter.Object, serverConnection: serverConn.Object))
{
s.SetProperty("State", SoulseekClientStates.Connected | SoulseekClientStates.LoggedIn);
var ex = await Record.ExceptionAsync(() => s.AddUserAsync(username));
Assert.NotNull(ex);
Assert.IsType <SoulseekClientException>(ex);
Assert.IsType <ConnectionException>(ex.InnerException);
}
}
public async Task AddUserAsync_Returns_Expected_Info(string username, bool exists, UserStatus status, int averageSpeed, int downloadCount, int fileCount, int directoryCount, string countryCode)
{
var result = new AddUserResponse(username, exists, status, averageSpeed, downloadCount, fileCount, directoryCount, countryCode);
var waiter = new Mock <IWaiter>();
waiter.Setup(m => m.Wait <AddUserResponse>(It.IsAny <WaitKey>(), null, It.IsAny <CancellationToken>()))
.Returns(Task.FromResult(result));
var serverConn = new Mock <IMessageConnection>();
serverConn.Setup(m => m.WriteAsync(It.IsAny <byte[]>(), It.IsAny <CancellationToken>()))
.Returns(Task.CompletedTask);
var s = new SoulseekClient("127.0.0.1", 1, waiter: waiter.Object, serverConnection: serverConn.Object);
s.SetProperty("State", SoulseekClientStates.Connected | SoulseekClientStates.LoggedIn);
var add = await s.AddUserAsync(username);
Assert.Equal(result.Username, add.Username);
Assert.Equal(result.Exists, add.Exists);
Assert.Equal(result.Status, add.Status);
Assert.Equal(result.AverageSpeed, add.AverageSpeed);
Assert.Equal(result.DownloadCount, add.DownloadCount);
Assert.Equal(result.FileCount, add.FileCount);
Assert.Equal(result.DirectoryCount, add.DirectoryCount);
Assert.Equal(result.CountryCode, add.CountryCode);
}
public void GetUsers()
{
UsersFacade usersFacade = new UsersFacade();
AddUserRequest addUserRequest = new AddUserRequest()
{
Username = AlphaNumericStringGenerator.GetString(10),
Password = AlphaNumericStringGenerator.GetString(10),
PasswordConfirm = AlphaNumericStringGenerator.GetString(10)
};
AddUserResponse addUserResponse = usersFacade.AddUser(addUserRequest);
Assert.AreEqual(HttpStatusCode.OK, addUserResponse.Status);
GetUsersResponse getUsersResponse = usersFacade.GetUsers();
Assert.AreEqual(HttpStatusCode.OK, getUsersResponse.Status);
Assert.IsNotNull(getUsersResponse.Users.Find(u => u.UserId == addUserResponse.UserId));
using (helpdesksystemContext context = new helpdesksystemContext())
{
var users = context.User.ToList();
Assert.IsNotNull(users);
}
}
private static string GetAddUserResponseFromExeption(WebException ex)
{
var addUserResponse = new AddUserResponse();
if (ex.Status == WebExceptionStatus.ProtocolError)
{
var response = ex.Response as HttpWebResponse;
if (response != null)
{
addUserResponse.code = (int)response.StatusCode;
addUserResponse.message = response.StatusDescription;
}
else
{
// no http status code available
}
}
else
{
// no http status code available
}
var json = JsonConvert.SerializeObject(addUserResponse);
return(json);
}
public void Parse_Returns_Expected_Data_When_User_Exists(string username, UserData userData)
{
var msg = new MessageBuilder()
.WriteCode(MessageCode.Server.AddUser)
.WriteString(username)
.WriteByte(1) // exists = true
.WriteInteger((int)userData.Status)
.WriteInteger(userData.AverageSpeed)
.WriteLong(userData.DownloadCount)
.WriteInteger(userData.FileCount)
.WriteInteger(userData.DirectoryCount)
.WriteString(userData.CountryCode)
.Build();
var r = AddUserResponse.FromByteArray(msg);
Assert.Equal(username, r.Username);
Assert.True(r.Exists);
Assert.Equal(userData.Status, r.UserData.Status);
Assert.Equal(userData.AverageSpeed, r.UserData.AverageSpeed);
Assert.Equal(userData.DownloadCount, r.UserData.DownloadCount);
Assert.Equal(userData.FileCount, r.UserData.FileCount);
Assert.Equal(userData.DirectoryCount, r.UserData.DirectoryCount);
Assert.Equal(userData.CountryCode, r.UserData.CountryCode);
}
public AddUserResponse AddUser(AddUserRequest request)
{
var response = new AddUserResponse {
Errors = new List <string>()
};
//TODO: validari
if (request.Age < 10)
{
response.Success = false;
response.Errors.Add("Age is lower than 10");
return(response);
}
_userRepository.Add(new User
{
Name = request.Name,
Age = request.Age,
Username = request.Username,
Password = Sha.Encrypt(request.Password),
UserImage = request.UserImage
});
response.Success = true;
return(response);
}
/// <summary>
/// Creates a new user to be used in both CLM and eSignature products
/// </summary>
/// <param name="userName">New user's user name</param>
/// <param name="firstName">New user's first name</param>
/// <param name="lastName">New user's last name</param>
/// <param name="email">New user's email address</param>
/// <param name="clmPermissionProfileId">CLM Permission Profile Id (GUID)</param>
/// <param name="eSignPermissionProfileId">eSignature Permission Profile Id (GUID)</param>
/// <param name="dsGroupId">DocuSign Group Id (GUID)</param>
/// <param name="clmProductId">CLM Product Id (GUID)</param>
/// <param name="eSignProductId">eSignature Product Id (GUID)</param>
/// <param name="basePath">BasePath for API calls (URI)</param>
/// <param name="accessToken">Access Token for API call (OAuth)</param>
/// <param name="orgId">DocuSign Organization Id (GUID)</param>
/// <param name="accountId">The DocuSign Account Id (GUID)</param>
/// <returns>The AddUserResponse object coming back from the API</returns>
public static AddUserResponse Create(string userName, string firstName, string lastName, string email, string clmPermissionProfileId, string eSignPermissionProfileId, Guid?dsGroupId, Guid?clmProductId, Guid?eSignProductId, string basePath, string accessToken, Guid?accountId, Guid?orgId)
{
// Step 5 Start
var apiClient = new ApiClient(basePath);
apiClient.Configuration.DefaultHeader.Add("Authorization", "Bearer " + accessToken);
UsersApi usersApi = new UsersApi(apiClient);
var newMultiProductUserAddRequest = new NewMultiProductUserAddRequest();
newMultiProductUserAddRequest.UserName = userName;
newMultiProductUserAddRequest.FirstName = firstName;
newMultiProductUserAddRequest.LastName = lastName;
newMultiProductUserAddRequest.Email = email;
var productPermissionProfiles = new List <ProductPermissionProfileRequest>();
productPermissionProfiles.Add(new ProductPermissionProfileRequest {
ProductId = clmProductId, PermissionProfileId = clmPermissionProfileId
});
productPermissionProfiles.Add(new ProductPermissionProfileRequest {
ProductId = eSignProductId, PermissionProfileId = eSignPermissionProfileId
});
newMultiProductUserAddRequest.ProductPermissionProfiles = productPermissionProfiles;
newMultiProductUserAddRequest.DsGroups = new List <DSGroupRequest>();
newMultiProductUserAddRequest.DsGroups.Add(new DSGroupRequest {
DsGroupId = dsGroupId
});
newMultiProductUserAddRequest.AutoActivateMemberships = true;
// Step 5 End
// Step 6 Start
AddUserResponse response = usersApi.AddOrUpdateUser(orgId, accountId, newMultiProductUserAddRequest);
// Step 6 End
return(response);
}
public AddUserResponse AddUser(AddUserRequest request)
{
var response = new AddUserResponse {
ResponseStatus = ResponseStatus.Success
};
var usersProvider = new UsersProvider();
try
{
if (request.ActionType == ActionType.Insert)
{
response.isSuccessful = usersProvider.InsertUser(request);
}
else
{
response.ResponseStatus = ResponseStatus.Failure;
response.ResponseDescription = "Not update action";
}
}
catch (Exception ex)
{
response.ResponseStatus = ResponseStatus.Failure;
response.ResponseDescription = ex.Message;
}
return(response);
}
public async Task Return_201_When_User_Registered()
{
var expectedUser =
new EntityFactory().NewUser(new Name("user-name"), new Email("email"), new Password("pass"), new PasswordSalt("salt"));
var expectedResponse = new AddUserResponse
{
UserId = expectedUser.Id.Value,
Name = expectedUser.Name.Value,
Email = expectedUser.Email.Value
};
_mediatorMock
.Setup(x => x.Send(It.IsAny <AddUserCommand>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(new AddUserCommandResult(expectedUser));
var actualResult = await _sut.AddNewUserAsync(
new AddUserRequest
{
Name = "user-name",
Email = "email",
Password = "******"
});
actualResult.Should()
.BeOfType <CreatedResult>()
.Which.Value
.Should()
.BeEquivalentTo(expectedResponse);
_mediatorMock.Verify(x => x.Send(It.IsAny <AddUserCommand>(), It.IsAny <CancellationToken>()), Times.Once);
}
public async Task GetUserStatusAsync_Throws_UserStatusException_On_Throw(string username, bool exists, UserStatus status, int averageSpeed, int downloadCount, int fileCount, int directoryCount, string countryCode)
{
var result = new AddUserResponse(username, exists, status, averageSpeed, downloadCount, fileCount, directoryCount, countryCode);
var waiter = new Mock <IWaiter>();
waiter.Setup(m => m.Wait <AddUserResponse>(It.IsAny <WaitKey>(), null, It.IsAny <CancellationToken>()))
.Returns(Task.FromResult(result));
var serverConn = new Mock <IMessageConnection>();
serverConn.Setup(m => m.WriteAsync(It.IsAny <byte[]>(), It.IsAny <CancellationToken>()))
.Throws(new ConnectionException("foo"));
var s = new SoulseekClient("127.0.0.1", 1, waiter: waiter.Object, serverConnection: serverConn.Object);
s.SetProperty("State", SoulseekClientStates.Connected | SoulseekClientStates.LoggedIn);
AddUserResponse r = null;
var ex = await Record.ExceptionAsync(async() => r = await s.AddUserAsync(username));
Assert.NotNull(ex);
Assert.IsType <AddUserException>(ex);
Assert.IsType <ConnectionException>(ex.InnerException);
}
public void UpdateUserUsernameExists()
{
UsersFacade usersFacade = new UsersFacade();
AddUserRequest addUserRequest = new AddUserRequest()
{
Username = AlphaNumericStringGenerator.GetString(10),
Password = AlphaNumericStringGenerator.GetString(10),
PasswordConfirm = AlphaNumericStringGenerator.GetString(10)
};
AddUserRequest addUserRequest2 = new AddUserRequest()
{
Username = AlphaNumericStringGenerator.GetString(10),
Password = AlphaNumericStringGenerator.GetString(10),
PasswordConfirm = AlphaNumericStringGenerator.GetString(10)
};
AddUserResponse addUserResponse = usersFacade.AddUser(addUserRequest);
AddUserResponse addUserResponse2 = usersFacade.AddUser(addUserRequest2);
Assert.AreEqual(HttpStatusCode.OK, addUserResponse.Status);
UpdateUserRequest updateUserRequest = new UpdateUserRequest()
{
Username = addUserResponse.Username,
Password = AlphaNumericStringGenerator.GetString(10)
};
UpdateUserResponse updateUserResponse = usersFacade.UpdateUser(addUserResponse2.UserId, updateUserRequest);
Assert.AreEqual(HttpStatusCode.BadRequest, updateUserResponse.Status);
}
public void Instantiates_With_The_Given_Data(string username, bool exists, UserData userData)
{
var r = new AddUserResponse(username, exists, userData);
Assert.Equal(username, r.Username);
Assert.Equal(exists, r.Exists);
Assert.Equal(userData, r.UserData);
}
public bool AddUser(string username, string password, bool anonymous, bool disabled, string site, string path, bool allowUpload, bool allowDownload, bool allowRename, bool allowDelete, bool allowDirectoryCreation, ref string message)
{
client.Url = ServiceUrl;
bool success = false;
AddUserRequest request = new AddUserRequest();
request.credentials = GetCredentials();
request.User = new User();
request.User.name = username;
request.User.password = new Password();
request.User.password.lastChange = DateTime.Now;
request.User.password.noExpire = true;
request.User.password.type = PasswordType.plain;
request.User.password.value = password;
request.User.maxLoginsAllowed = new UserPropertyInt();
request.User.maxLoginsAllowed.valueSpecified = true;
request.User.maxLoginsAllowed.value = 10;
request.User.isSimpleDirectoryMode = new UserPropertyBool();
request.User.isSimpleDirectoryMode.valueSpecified = true;
request.User.isSimpleDirectoryMode.value = true;
request.User.isAnonymous = new UserPropertyBool();
request.User.isAnonymous.valueSpecified = true;
request.User.isAnonymous.value = false;
request.User.isDisabled = new UserPropertyBool();
request.User.isDisabled.valueSpecified = true;
request.User.isDisabled.value = false;
request.User.rootList = new VirtualDirectory[1];
request.User.rootList[0] = new VirtualDirectory();
request.User.rootList[0].name = site;
request.User.rootList[0].path = path;
request.User.rootList[0].permissions = new DirectoryPermissions();
request.User.rootList[0].permissions.allowListDir = true;
request.User.rootList[0].permissions.allowListFile = true;
request.User.rootList[0].permissions.allowUpload = allowUpload;
request.User.rootList[0].permissions.allowDownload = allowDownload;
request.User.rootList[0].permissions.allowDisplayHidden = false;
request.User.rootList[0].permissions.allowRename = allowRename;
request.User.rootList[0].permissions.allowDelete = allowDelete;
request.User.rootList[0].permissions.allowDirectoryCreation = allowDirectoryCreation;
AddUserResponse response = client.AddUser(request);
if (response != null)
{
success = response.result;
message = response.message;
}
return(success);
}
public void Parse_Throws_MessageException_On_Code_Mismatch()
{
var msg = new MessageBuilder()
.WriteCode(MessageCode.Peer.BrowseRequest)
.Build();
var ex = Record.Exception(() => AddUserResponse.FromByteArray(msg));
Assert.NotNull(ex);
Assert.IsType <MessageException>(ex);
}
public void Parse_Throws_MessageReadException_On_Missing_Data()
{
var msg = new MessageBuilder()
.WriteCode(MessageCode.Server.AddUser)
.Build();
var ex = Record.Exception(() => AddUserResponse.FromByteArray(msg));
Assert.NotNull(ex);
Assert.IsType <MessageReadException>(ex);
}
/// <summary>
/// Add a user to a station
/// </summary>
/// <param name="email"></param>
/// <param name="password"></param>
/// <returns>station's session token</returns>
/// <exception cref="Wammer.Station.Management.AuthenticationException">
/// Invalid user name or password
/// </exception>
/// <exception cref="Wammer.Station.Management.StationAlreadyHasDriverException">
/// The station already has an driver
/// </exception>
/// <exception cref="Wammer.Station.Management.UserAlreadyHasStationException">
/// The user already has a station. The station's info, such as id/location/sync time, can
/// be retrieved from the exception
/// </exception>
/// <exception cref="Wammer.Station.Management.StationServiceDownException">
/// Unable to connect to station service, service down?
/// </exception>
/// <exception cref="Wammer.Station.Management.ConnectToCloudException">
/// Unable to connect to waveface cloud, network down?
/// </exception>
public static AddUserResult AddUser(string email, string password)
{
try
{
AddUserResponse res = CloudServer.request <AddUserResponse>(
new WebClient(),
StationMgmtURL + "station/drivers/add",
new Dictionary <object, object> {
{ "email", email },
{ "password", password }
});
return(new AddUserResult()
{
UserId = res.UserId, IsPrimaryStation = res.IsPrimaryStation
});
}
catch (Cloud.WammerCloudException e)
{
if (e.HttpError == WebExceptionStatus.ConnectFailure)
{
throw new StationServiceDownException("Station service down?");
}
switch (e.WammerError)
{
case (int)StationApiError.ConnectToCloudError:
throw new ConnectToCloudException(e.Message);
case (int)StationApiError.AuthFailed:
throw new AuthenticationException(e.Message);
case (int)StationApiError.DriverExist:
throw new StationAlreadyHasDriverException(e.Message);
case (int)StationApiError.AlreadyHasStaion:
StationSignUpResponse resp = fastJSON.JSON.Instance.
ToObject <Cloud.StationSignUpResponse>(e.response);
throw new UserAlreadyHasStationException
{
Id = resp.station.station_id,
Location = resp.station.location,
LastSyncTime = resp.station.LastSeen,
ComputerName = resp.station.computer_name
};
case 0x4000 + 4: // user not exist
throw new AuthenticationException(e.Message);
default:
throw;
}
}
}
public AddUserResponse DeleteUser(int id)
{
var response = new AddUserResponse
{
Errors = new List <string>()
};
_userRepository.Delete(id);
response.Success = true;
return(response);
}
public void Instantiates_With_The_Given_Data(string username, bool exists, UserStatus?status, int?averageSpeed, long?downloadCount, int?fileCount, int?directoryCount, string countryCode)
{
var r = new AddUserResponse(username, exists, status, averageSpeed, downloadCount, fileCount, directoryCount, countryCode);
Assert.Equal(username, r.Username);
Assert.Equal(exists, r.Exists);
Assert.Equal(averageSpeed, r.AverageSpeed);
Assert.Equal(downloadCount, r.DownloadCount);
Assert.Equal(fileCount, r.FileCount);
Assert.Equal(directoryCount, r.DirectoryCount);
Assert.Equal(countryCode, r.CountryCode);
}
public IHttpActionResult AddUser(AddUser AUser)
{
ObjectParameter rc = new ObjectParameter("rc", typeof(int));
ObjectParameter em = new ObjectParameter("errormessage", typeof(string));
db.addUser(AUser.Hash, AUser.UserName, AUser.SupplierCode, AUser.FullName, AUser.Telephone, AUser.AdminLevel, rc, em);
AddUserResponse aur = new AddUserResponse();
aur.ReturnCode = (int)rc.Value;
aur.appendError((string)em.Value);
return(Ok(aur));
}
private async Task AssertUserIsPersistedAsync(AddUserResponse response)
{
var userRepository = _fixture.TestServer.Services.GetService <IUserRepository>();
userRepository.Should().NotBeNull();
var persistedUser = await userRepository.SelectByEmailAsync(new Email(response.Email), _cancellation.Token);
persistedUser.Should().NotBeNull();
persistedUser.Name.Value.Should().Be(response.Name);
persistedUser.Email.Value.Should().Be(response.Email);
}
public override Response DoWork(string request)
{
var workRequest = JsonConvert.DeserializeObject<AddUserRequest>(request);
var workResponse = new AddUserResponse();
var user = new User {Name = workRequest.UserName};
workResponse.Status = Statuses.Ok;
if (!Server.Users.TryAdd(user.Name, user))
{
workResponse.Status = Statuses.DuplicateUser;
}
return workResponse;
}
public static void ProcessLogin(Array rows)
{
LoginRow row = (LoginRow)rows[0];
jQuery.Post("/Services/AddUser?signed_request=" + Utility.GetSignedRequest(), new JsonObject("member", new JsonObject()), (AjaxRequestCallback <object>) delegate(object data, string textStatus, jQueryXmlHttpRequest <object> request)
{
WebServiceResponse response = (WebServiceResponse)data;
AddUserResponse addUser = (AddUserResponse)response.Data;
//
}
);
}
public void AddUserEmptyUsername()
{
UsersFacade usersFacade = new UsersFacade();
AddUserRequest addUserRequest = new AddUserRequest();
addUserRequest.Username = "";
addUserRequest.Password = "******";
addUserRequest.PasswordConfirm = "Password1";
AddUserResponse addUserResponse = usersFacade.AddUser(addUserRequest);
Assert.AreEqual(HttpStatusCode.BadRequest, addUserResponse.Status);
}
public void Parse_Returns_Expected_Data_When_User_Does_Not_Exist(string username)
{
var msg = new MessageBuilder()
.WriteCode(MessageCode.Server.AddUser)
.WriteString(username)
.WriteByte(0) // exists = false
.Build();
var r = AddUserResponse.FromByteArray(msg);
Assert.Equal(username, r.Username);
Assert.False(r.Exists);
Assert.Null(r.UserData);
}
public ActionResult Add(UsersAddModel model)
{
var request = new AddUserRequest
{
Customer = Customer.OriginalCustomer,
CustomerId = Customer.CustomerId,
Model = model
};
AddUserResponse response = _userService.Add(request);
return(RedirectToAction("update", new { id = response.UserID })
.AndAlert(AlertType.Success, "Success.", "System user added successfully."));
}
public void AddUserUsernameTooLong()
{
UsersFacade usersFacade = new UsersFacade();
AddUserRequest addUserRequest = new AddUserRequest();
addUserRequest.Username = AlphaNumericStringGenerator.GetString(21);
addUserRequest.Password = "******";
addUserRequest.PasswordConfirm = "Password1";
AddUserResponse addUserResponse = usersFacade.AddUser(addUserRequest);
Assert.AreEqual(HttpStatusCode.BadRequest, addUserResponse.Status);
}
/// <summary>
/// This method is responsible for adding a new user.
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
public AddUserResponse AddUser(AddUserRequest request)
{
s_logger.Info("Adding user...");
AddUserResponse response = new AddUserResponse();
try
{
response = (AddUserResponse)request.CheckValidation(response);
if (response.Status == HttpStatusCode.BadRequest)
{
return(response);
}
if (string.IsNullOrEmpty(request.Password))
{
request.Password = request.Username;
}
request.Password = HashText(request.Password);
var dataLayer = new UsersDataLayer();
if (dataLayer.GetUserByUsername(request.Username) != null)
{
response.Status = HttpStatusCode.Forbidden;
response.StatusMessages.Add(new StatusMessage(HttpStatusCode.Forbidden, "Username already exists"));
return(response);
}
int?result = dataLayer.AddUser(request);
if (result == null)
{
throw new Exception("Unable to add user!");
}
response.UserId = (int)result;
response.Status = HttpStatusCode.OK;
}
catch (Exception ex)
{
s_logger.Error(ex, "Unable to add user!");
response.Status = HttpStatusCode.InternalServerError;
response.StatusMessages.Add(new StatusMessage(HttpStatusCode.InternalServerError, "Unable to add user!"));
}
return(response);
}
public static AddUserResponse Unmarshall(UnmarshallerContext context)
{
AddUserResponse addUserResponse = new AddUserResponse();
addUserResponse.HttpResponse = context.HttpResponse;
addUserResponse.ErrorMessage = context.StringValue("AddUser.ErrorMessage");
addUserResponse.ErrorCode = context.StringValue("AddUser.ErrorCode");
addUserResponse.Message = context.StringValue("AddUser.Message");
addUserResponse.DynamicCode = context.StringValue("AddUser.DynamicCode");
addUserResponse.Code = context.StringValue("AddUser.Code");
addUserResponse.DynamicMessage = context.StringValue("AddUser.DynamicMessage");
addUserResponse.RequestId = context.StringValue("AddUser.RequestId");
addUserResponse.Success = context.BooleanValue("AddUser.Success");
return(addUserResponse);
}
