/// <summary>
/// 新增
/// </summary>
/// <param name="request"></param>
/// <returns></returns>
public async Task <ApiResult <string> > InsertAsync(InsertUserRequest request)
{
return(await ExecuteResultAsync(async query =>
{
var rsp = new ApiResult <string>();
var entity = new User
{
UserName = request.UserName,
Password = request.Password,
PhoneNumber = request.PhoneNumber,
RealName = request.RealName,
Email = request.Email,
AvatarUrl = request.AvatarUrl
};
// 新增
await RegisterNewAsync(entity);
// 提交
var flag = await CommitAsync();
rsp.Message = flag ? "新增成功" : "新增失败";
rsp.Success = flag;
rsp.Data = entity.Id;
return rsp;
}));
}
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 ActionResult Create(UserModel user)
{
if (!ModelState.IsValid)
{
return(View("Create"));
}
var emailExists = JsonConvert.DeserializeObject <bool>
(ServiceApiUtil.ApiResponse("api/user/EmailExists?request=" + user.Email, "GET"));
if (emailExists)
{
ModelState.AddModelError("", "E-mail já cadastrado.");
return(View(user));
}
var request = new InsertUserRequest()
{
Email = user.Email,
Password = Utils.Utils.PassGenerate(user.Password)
};
var response = JsonConvert.DeserializeObject <InsertUserResponse>
(ServiceApiUtil.ApiResponse("api/user/Insert", "POST", request));
return(RedirectToAction("Login", new { returnUrl = "", message = "Usuário criado com sucesso." }));
}
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 InsertUserResponse InsertUser(InsertUserRequest request)
{
User user = null;
if (request == null)
{
AddNotification("InsertFileRequest", "Request is required.");
}
if (_repositoryUser.EmailExists(request.Email))
{
AddNotification("Email exists", "Esse e-mail já está cadastrado");
}
else
{
user = new User(request?.Email, request?.Password);
AddNotifications(user);
}
if (IsInvalid())
{
return(null);
}
user = _repositoryUser.Insert(user);
return((InsertUserResponse)user);
}
public InsertUserResponse InsertUser(InsertUserRequest request)
{
var response = _innerService.InsertUser(request);
NotifyIfException(response);
return(response);
}
public async Task <IActionResult> Index(InsertUserRequest user)
{
var abc = await _mediator.Send(user);
if (abc)
{
return(StatusCode(200));
}
return(StatusCode(400));
}
public void InsertUserProfile(InsertUserRequest model)
{
DataProvider.ExecuteNonQuery(GetConnection, "storedProcName"
, inputParamMapper : delegate(SqlParameterCollection paramCollection)
{
paramCollection.AddWithValue("@FirstName", model.FirstName);
paramCollection.AddWithValue("@LastName", model.LastName);
}
);
}
public async Task <bool> InsertUserDetailsAsync(InsertUserRequest UserDetails)
{
try
{
var context = new UserDetailsContext();
var UserInformation = new UserDetail();
UserInformation.UserEmail = UserDetails.UserEmail;
UserInformation.FirstName = UserDetails.FirstName;
UserInformation.LastName = UserDetails.LastName;
UserInformation.PhoneNumber = UserDetails.PhoneNumber;
UserInformation.UserTypeId = (int)Enum.Parse(typeof(UserAccessType), UserDetails.UserStatus) + 1;
var result = await context.AddAsync(UserInformation);
await context.SaveChangesAsync();
Debug.Write(result);
return(true);
/*string connectionstring =
* "Data Source=DESKTOP-02T0GUH\\SQLEXPRESS;Initial Catalog = UserDetails; User ID = DESKTOP-02T0GUH\\sonij; Password='';Integrated Security=true;";
* SqlConnection conn = new SqlConnection(connectionstring);
* string query = "INSERT INTO UserDetails (FirstName,LastName,UserEmail,UserTypeId,PhoneNumber) VALUES (@firstname,@lastname,@useremail,@userTypeId,@phonenumber)";
* using (SqlCommand cmd = new SqlCommand(query, conn))
* {
* //@phonenumber
* cmd.CommandType = CommandType.Text;
* conn.Open();
*
* cmd.Parameters.AddWithValue("@userTypeId", (int)Enum.Parse(typeof(UserAccessType), UserDetails.UserStatus) + 1);
* cmd.Parameters.AddWithValue("@firstname", UserDetails.FirstName.ToString());
* cmd.Parameters.AddWithValue("@lastname", UserDetails.LastName.ToString());
* cmd.Parameters.AddWithValue("@useremail", UserDetails.UserEmail.ToString());
* cmd.Parameters.AddWithValue("@phonenumber", UserDetails.PhoneNumber.ToString());
* try
* {
* var reader = await cmd.ExecuteNonQueryAsync();
* conn.Close();
* return true;
* //return false;
* }
* catch (Exception e)
* {
* Debug.WriteLine(e);
* conn.Close();
* return false;
* }
* }*/
}
catch (Exception e)
{
Debug.Write(e);
return(false);
}
}
public User Update(int userId, InsertUserRequest request)
{
var user = _context.Users.Find(userId);
_mapper.Map(request, user);
_context.SaveChanges();
_accoutnService.Update(user.AccountId, request);
return(_mapper.Map <Model.User>(user));
}
public ActionResult Create(UserDTO user)
{
var serviceRequest = new InsertUserRequest
{
UserProperties = user
};
var serviceResponse = _userService.InsertUser(serviceRequest);
HandleServiceException(serviceResponse);
return(GetEditView(user, SaveMode.Create));
}
public async Task <HttpResponseMessage> Insert(InsertUserRequest request)
{
try
{
var response = _serviceUser.InsertUser(request);
return(await ResponseAsync(response, _serviceUser));
}
catch (Exception ex)
{
return(await ResponseExceptionAsync(ex));
}
}
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 void InsertUserInvalidAddressTest()
{
var userRequest = new InsertUserRequest {
UserProperties = new UserEditDTO {
FirstName = "test",
LastName = "test",
City = "London",
Street = "Baker street",
HouseNumber = "221B"
}
};
var expectedUser = new Domain.User.User {
Id = Guid.NewGuid(),
FirstName = userRequest.UserProperties.FirstName,
LastName = userRequest.UserProperties.LastName,
Address = new Address {
Country = userRequest.UserProperties.Country,
City = userRequest.UserProperties.City,
Street = userRequest.UserProperties.Street,
HouseNumber = userRequest.UserProperties.HouseNumber
}
};
var mockUow = new Mock <IUnitOfWork>();
var mockRepo = new Mock <IUserRepository>();
mockRepo.Setup(x => x.Insert(expectedUser));
var mockMapper = new Mock <IUserDtoMapper>();
mockMapper.Setup(x => x.ConvertToDomainObject(userRequest.UserProperties)).Returns(expectedUser);
var mockValidator = new Mock <IValidator <Domain.User.User> >();
mockValidator.Setup(x => x.GetBrokenRules(expectedUser)).Returns(new List <BusinessRule> {
AddressBusinessRules.AddressCountryRequired
});
var service = new UserService(mockUow.Object, mockRepo.Object, mockMapper.Object, mockValidator.Object);
var response = service.InsertUser(userRequest);
Assert.IsFalse(response.Result);
Assert.IsNotNull(response.Exception);
Assert.AreEqual(typeof(ValidationException), response.Exception.GetType());
mockRepo.Verify(x => x.Insert(expectedUser), Times.Never);
mockUow.Verify(x => x.Commit(), Times.Never);
}
public HttpResponseMessage InsertUser(InsertUserRequest model)
{
if (!ModelState.IsValid)
{
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, ModelState));
}
List <UserProfile> response = new List <UserProfile>();
UserService list = new UserService();
// response = list.InsertUserProfile(model);
return(Request.CreateResponse(HttpStatusCode.OK, response));
}
public Model.User Insert(InsertUserRequest request)
{
var user = _mapper.Map <Database.Users>(request);
request.Role = Role.Korisnik;
var accountId = _accoutnService.Insert(request).AccountId;
user.AccountId = accountId;
user.Locked = false;
user.Active = true;
_context.Users.Add(user);
_context.SaveChanges();
return(_mapper.Map <Model.User>(user));
}
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 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 async Task <TResponse <bool> > Insert(InsertUserRequest request)
{
try
{
var url = ApiUrl.USER_INSERT;
var response = await HttpService.Send <bool>(url,
request,
HttpMethod.Post,
true);
if (response.IsSuccess)
{
return(await Ok(true));
}
return(await Fail <bool>(response.Message));
}
catch (Exception exception)
{
return(await Fail <bool>(exception));
}
}
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 InsertUserResponse InsertUser(InsertUserRequest request)
{
User user = null;
if (request == null)
{
AddNotification("InsertFileRequest", "Request is required.");
}
else
{
user = new User(request.Email, request.Password);
user = _repositoryUser.Insert(user);
}
AddNotifications(user);
if (IsInvalid())
{
return(null);
}
return((InsertUserResponse)user);
}
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 abstract InsertUserResponse OnInsertUserExecute(InsertUserRequest request);
public async Task <ApiResult <string> > Create([FromBody] InsertUserRequest request)
{
// 密码加密
request.Password = PasswordHash.PasswordHash.CreateHash(request.Password);
return(await _userService.InsertAsync(request));
}
