public virtual InsertUserResponse InsertUser(InsertUserRequest request)
{
var response = new InsertUserResponse();
try {
// Raise Initialization Event
var initialization = InsertUserInitialization;
if (initialization != null)
{
initialization(request, response);
}
// Raise Execute Event
var execute = InsertUserExecute;
if (execute != null)
{
response = execute(request);
}
// Raise Complete Event
var complete = InsertUserComplete;
if (complete != null)
{
complete(request, response);
}
}
catch (Exception exception) {
// Raise Error Event
var error = InsertUserError;
if (error != null)
{
error(request, response, exception);
}
}
return(response);
}
public ActionResult InsertUser(string userViewModel)
{
UserViewModel viewModel = JsonConvert.DeserializeObject <UserViewModel>(userViewModel);
viewModel.AccountID = this.Identity.ToAccountID();
viewModel.CreatedBy = this.Identity.ToUserID();
viewModel.CreatedOn = DateTime.Now.ToUniversalTime();
viewModel.IsDeleted = false;
InsertUserRequest request = new InsertUserRequest()
{
UserViewModel = viewModel
};
var serviceprovider = serviceProviderService.ServiceproviderToSendTransactionEmails(this.Identity.ToAccountID());
if (serviceprovider.LoginToken == new Guid())
{
throw new UnsupportedOperationException("[|Communication Providers are not configured for this Account.|]");
}
InsertUserResponse response = userService.InsertUser(request);
var name = response.UserViewModel.FirstName + " " + response.UserViewModel.LastName;
string filename = EmailTemplate.UserRegistration.ToString() + ".txt";
if (viewModel.DoNotEmail == false)
{
SendEmail(response.UserViewModel.UserID.ToString(), response.UserViewModel.AccountID.ToString(), response.UserViewModel.PrimaryEmail, name, filename, this.Identity.ToAccountPrimaryEmail(), string.Empty);
}
return(Json(new
{
success = true,
response = ""
}, JsonRequestBehavior.AllowGet));
}
public HttpResponseMessage PostUser(UserViewModel viewModel)
{
InsertUserResponse response = userService.InsertUser(new InsertUserRequest()
{
UserViewModel = viewModel
});
return(Request.BuildResponse(response));
}
public void InsertUserInvalidTest()
{
var request = new InsertUserRequest {
UserProperties = new UserEditDTO {
FirstName = "test",
LastName = "test",
Country = "UK",
City = "London",
Street = "Baker street",
HouseNumber = "221B"
}
};
var expectedResonse = new InsertUserResponse {
Exception = new ValidationException("invalid")
};
var mockService = new Mock <IUserService>();
mockService.Setup(x => x.InsertUser(request)).Returns(expectedResonse);
var mockLogger = new Mock <ILoggingService>();
var mockEmail = new Mock <IEmailService>();
mockEmail.Setup(x => x.SendEmail(It.IsAny <EmailArguments>()));
var mockConfigOptions = new Mock <IServiceConfigOptions>();
mockConfigOptions.Setup(x => x.AdminEmail).Returns("test");
mockConfigOptions.Setup(x => x.ErrorEmailSubject).Returns("test");
mockConfigOptions.Setup(x => x.SmtpServer).Returns("test");
mockConfigOptions.Setup(x => x.SystemEmail).Returns("test");
var mockConfig = new Mock <IAppConfig <IServiceConfigOptions> >();
mockConfig.Setup(x => x.Options).Returns(mockConfigOptions.Object);
var service = new EnrichedUserService(mockService.Object, mockLogger.Object, mockEmail.Object,
mockConfig.Object);
var response = service.InsertUser(request);
Assert.IsNotNull(response.Exception);
mockLogger.Verify(x => x.LogError(It.IsAny <object>(), "invalid", It.IsAny <ValidationException>()),
Times.Once);
mockEmail.Verify(x => x.SendEmail(It.IsAny <EmailArguments>()), Times.Once);
}
public async Task <InsertUserResponse[]> InsertNewUser(UserInsertRequest[] users)
{
List <InsertUserResponse> responses = new List <InsertUserResponse>();
foreach (UserInsertRequest user in users)
{
HttpResponseMessage response = await HttpClient.PostAsJsonAsync("api/v1/users/create", user);
response.EnsureSuccessStatusCode();
InsertUserResponse ret = JsonConvert.DeserializeObject <InsertUserResponse>(response.Content.ReadAsStringAsync().Result);
responses.Add(ret);
}
return(responses.ToArray());
}
private async Task <JsonResult> ExecutePut(InsertUserResponse response)
{
var methodResponse = new GenericManagerResponse <AuthToken, InsertUserResponse>(response, new AuthToken());
var userManager = new Mock <IUserManager>();
userManager.Setup(c => c.InsertUserAsync(It.IsAny <User>()))
.Returns <User>(u =>
Task.FromResult(methodResponse));
var controller = new UsersController(userManager.Object);
var result = await controller.Put(new User());
return(result);
}
public void PostInvalidTest()
{
var input = new UserEditDTO {
FirstName = null,
LastName = null,
Country = "UK",
City = "London",
Street = "Baker street",
HouseNumber = "221B"
};
var expected = new InsertUserResponse {
Result = false,
Exception = new ValidationException("name")
};
var mockService = new Mock <IUserService>();
mockService.Setup(x => x.InsertUser(It.IsAny <InsertUserRequest>())).Returns(expected);
var mockRespoonseBuilder = new Mock <IHttpResponseBuilder>();
var controller = new UserController(mockService.Object, mockRespoonseBuilder.Object)
{
Request = new HttpRequestMessage(),
Configuration = new HttpConfiguration()
};
mockRespoonseBuilder.Setup(x => x.BuildResponse(It.IsAny <HttpRequestMessage>(), expected))
.Returns(new HttpResponseMessage(HttpStatusCode.BadRequest)
{
Content = new StringContent(expected.Exception.Message)
});
var response = controller.Post(input);
bool result;
response.TryGetContentValue(out result);
Assert.IsFalse(result);
Assert.AreEqual(HttpStatusCode.BadRequest, response.StatusCode);
mockService.Verify(x => x.InsertUser(It.IsAny <InsertUserRequest>()), Times.Once);
}
public HttpResponseMessage Post([FromBody] UserEditDTO user)
{
var request = new InsertUserRequest {
UserProperties = user
};
var response = new InsertUserResponse();
try
{
response = _userService.InsertUser(request);
}
catch (Exception ex)
{
response.Exception = ex;
}
return(_responseBuilder.BuildResponse(Request, response));
}
public override InsertUserResponse OnInsertUserExecute(InsertUserRequest request)
{
InsertUserResponse response = new InsertUserResponse();
try
{
var user = _mapperService.Map <Usuario>(request.Usuario);
_usuarioRepository.Insert(user);
_unitOfWork.Commit();
response.Usuario = _mapperService.Map <UsuarioDto>(user);
}
catch (Exception ex)
{
response.Exception = ex;
}
return(response);
}
public void InsertUser_ToAddNewUser_Success()
{
IList <UserViewModel> viewModelList = UserMockData.GetUserViewModel();
int count = viewModelList.Count();
viewModelList.Add(new UserViewModel()
{
FirstName = "UserFirstName", LastName = "UserLastName", RoleID = 2, PrimaryEmail = "*****@*****.**"
});
User user = UserMockData.GetUserClass();
mockUserRepository.Setup(cr => cr.Insert(It.IsAny <User>())).Verifiable();
InsertUserResponse response = userService.InsertUser(new InsertUserRequest()
{
UserViewModel = viewModelList.Last()
});
mockRepository.VerifyAll();
Assert.AreNotEqual(count, viewModelList.Count());
Assert.AreEqual(null, response.Exception);
}
public void PostTest()
{
var input = new UserEditDTO {
FirstName = "test",
LastName = "test",
Country = "UK",
City = "London",
Street = "Baker street",
HouseNumber = "221B"
};
var expected = new InsertUserResponse {
Result = true
};
var mockService = new Mock <IUserService>();
mockService.Setup(x => x.InsertUser(It.IsAny <InsertUserRequest>())).Returns(expected);
var mockRespoonseBuilder = new Mock <IHttpResponseBuilder>();
var controller = new UserController(mockService.Object, mockRespoonseBuilder.Object)
{
Request = new HttpRequestMessage(),
Configuration = new HttpConfiguration()
};
mockRespoonseBuilder.Setup(x => x.BuildResponse(controller.Request, expected))
.Returns(controller.Request.CreateResponse(HttpStatusCode.OK, expected.Result));
var response = controller.Post(input);
bool result;
response.TryGetContentValue(out result);
Assert.IsTrue(result);
Assert.AreEqual(HttpStatusCode.OK, response.StatusCode);
mockService.Verify(x => x.InsertUser(It.IsAny <InsertUserRequest>()), Times.Once);
}
public InsertUserResponse InsertUser(InsertUserRequest request)
{
var response = new InsertUserResponse();
try
{
var newUser = _userMapper.ConvertToDomainObject(request.UserProperties);
ThrowExceptionIfUserIsInvalid(newUser);
_userRepository.Insert(newUser);
_uow.Commit();
response.Result = true;
return(response);
}
catch (Exception ex)
{
response.Exception = ex;
return(response);
}
}
public void InsertUserTest()
{
var request = new InsertUserRequest {
UserProperties = new UserEditDTO {
FirstName = "test",
LastName = "test",
Country = "UK",
City = "London",
Street = "Baker street",
HouseNumber = "221B"
}
};
var expectedResonse = new InsertUserResponse {
Exception = null
};
var mockService = new Mock <IUserService>();
mockService.Setup(x => x.InsertUser(request)).Returns(expectedResonse);
var mockLogger = new Mock <ILoggingService>();
var mockEmail = new Mock <IEmailService>();
var mockConfig = new Mock <IAppConfig <IServiceConfigOptions> >();
var service = new EnrichedUserService(mockService.Object, mockLogger.Object, mockEmail.Object,
mockConfig.Object);
var response = service.InsertUser(request);
Assert.IsNull(response.Exception);
Assert.AreEqual(expectedResonse.Exception, response.Exception);
mockService.Verify(x => x.InsertUser(request), Times.Once);
}
public async Task PutError(HttpStatusCode expected, InsertUserResponse result)
{
var actual = await ExecutePut(result);
Assert.AreEqual(expected, (HttpStatusCode)actual.StatusCode);
}
