public ActionResult <UserResponseDTO> Create(UserRequestDTO userDTO)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var user = Mapper.Mapper.Map <User>(userDTO);
try
{
if (_userService.Add(user))
{
return(NoContent());
}
else
{
return(BadRequest());
}
}
catch
{
return(BadRequest());
}
}
public async Task <RegistrationResponseDTO> RegisterUser(UserRequestDTO userForRegistration)
{
try
{
var content = JsonConvert.SerializeObject(userForRegistration);
var bodyContent = new StringContent(content, Encoding.UTF8, "application/json");
var response = await _httpClient.PostAsync("api/account/signup", bodyContent);
var contentTemp = await response.Content.ReadAsStringAsync();
// Enitity to DTO convert is alrdy done in repository
var result = JsonConvert.DeserializeObject <RegistrationResponseDTO>(contentTemp);
if (response.IsSuccessStatusCode)
{
return(new RegistrationResponseDTO {
IsRegistrationSuccessful = true
});
}
else
{
return(result);
}
}
catch (Exception e)
{
throw new Exception(e.Message);
}
}
public object CreateNewUser([FromBody] UserRequestDTO userData)
{
string token = Request.Headers.Authorization == null ? "" : Request.Headers.Authorization.ToString();
Logger.Info(Request.RequestUri + " || Method: " + Request.Method, Request.Headers.ToString(), JsonConvert.SerializeObject(userData), Level.INFO);
ResponseDTO Response = new ResponseDTO();
ErrorDTO ErrorResponse = new ErrorDTO();
UserResponseDTO UserResponse = new UserResponseDTO();
Response = UserBUS.GetAllUserInfo(userData.username, "", 0);
if (Response.Data == null)
{
Response = UserBUS.AddOrUpdateUser(userData);
}
else
{
ErrorResponse.Code = 400;
ErrorResponse.Message = "Tài khoản đã tồn tại";
Response.Error = ErrorResponse;
Response.Data = null;
}
return(Response);
}
public async Task <ActionResult> Post(UserRequestDTO model)
{
_logger.LogRequest("Requesting user login for user: {UserName}, password: {Password}", model?.Username, model?.Password);
var user = await _user.Authenticate(model.Username, model.Password);
if (user.ResponseCode != "200")
{
_logger.LogError("Error authentication for user: {UserName}, password: {Password}", model?.Username, model?.Password);
return(StatusCode(500, user.ResponseMessage));
}
if (user.ResponseData == null)
{
_logger.LogWarning("Not found for user: {UserName}, password: {Password}", model?.Username, model?.Password);
return(BadRequest(user));
}
_logger.LogResponse("Success authentication for user: {UserName}, password: {Password}", model?.Username, model?.Password);
//generate token
_logger.LogRequest("Request generate token");
var tokenJWT = await GenerateToken(user.ResponseData.Id, user.ResponseData.Username, user.ResponseData.Fullname);
_logger.LogResponse("Retrieve generate token {Token}", tokenJWT.Token);
return(Ok(tokenJWT));
}
public HttpResponseMessage CreateUser([FromBody] UserRequestDTO data)
{
var respMessage = new HttpResponseMessage();
if (data == null)
{
return(BaseController.Security.GetMessageNotCreateUser(respMessage, "Dados inválidos"));
}
if (string.IsNullOrWhiteSpace(data.email))
{
return(BaseController.Security.GetMessageNotCreateUser(respMessage, "E-mail não informado"));
}
if (string.IsNullOrWhiteSpace(data.nickName))
{
return(BaseController.Security.GetMessageNotCreateUser(respMessage, "Usuário não informado"));
}
if (string.IsNullOrWhiteSpace(data.codeIn))
{
return(BaseController.Security.GetMessageNotCreateUser(respMessage, "Senha não informada"));
}
if (!BaseController.Security.IsValidEmail(data.email))
{
return(BaseController.Security.GetMessageInvalidMail(respMessage));
}
else
{
data.codeIn = EncodeDecode.CrashOut(data.codeIn);
data.repeatCodeIn = EncodeDecode.CrashOut(data.repeatCodeIn);
BaseController.Security.GetMessageCreateUser(respMessage, _userBusiness.InsertUser(data));
}
return(respMessage);
}
public async Task <ActionResult <IResponseObject> > PostUser(UserRequestDTO userDTO)
{
if (await _userRepository.GetByEmail(userDTO.Email) != null)
{
return(UserCreationConflict(EmailInUseErrorDetail));
}
if (await _userRepository.GetByUsername(userDTO.Username) != null)
{
return(UserCreationConflict(UsernameTakenErrorDetail));
}
User user = _mapper.Map <User>(userDTO);
user.Email = user.Email;
user.Username = user.Username;
user.PasswordHash = _passwordHasher.HashPassword(userDTO.Password);
user.Role = UserRole.User;
user.Verified = false;
await _userRepository.Create(user);
string siteUrl = string.IsNullOrEmpty(userDTO.SiteUrlOverride) ?
$"{HttpContext.Request.Scheme}{Uri.SchemeDelimiter}{HttpContext.Request.Host}" : userDTO.SiteUrlOverride;
await _verificationTokenRepository.CreateDefaultAndEmail(user.Email, user.Username, siteUrl);
return(CreatedAtAction("GetUser", new { id = user.Id }, _mapper.Map <UserResponseDTO>(user)));
}
public DALInit(IUserRepository userRepository, IMapper mapper, IPasswordHasher passwordHasher, IOptionsMonitor <UserRequestDTO> adminUserConfig)
{
_userRepository = userRepository;
_mapper = mapper;
_passwordHasher = passwordHasher;
_adminUser = adminUserConfig.CurrentValue;
}
public Guid Insert(UserRequestDTO request)
{
var entity = Mapper.Map <UserEntity>(request);
_userRepository.Insert(entity);
return(entity.Id);
}
public async Task Create(UserRequestDTO request)
{
var firstPassword = GenerateFirstPassword(request.Name);
var user = new User(request.Name, request.EmailLogin, firstPassword, request.Role);
await _userRepository.Create(user);
_emails.SendEmailNewUser(user.EmailLogin, user.Password);
}
public HttpResponseMessage CreateUser(UserRequestDTO userDTO)
{
if (userDTO != null)
{
var user = _userServices.CreateUserLogin(userDTO.loginUsername, userDTO.loginPassword);
return(Request.CreateResponse(HttpStatusCode.OK, user));
}
return(Request.CreateErrorResponse(HttpStatusCode.NotFound, "No username or password sent"));
}
// <summary>
/// Se actualiza la infomación de un usuario
/// </summary>
/// <param name="request"></param>
/// <returns>Regresa ibjeto de tipo UserDTO</returns>
public ResponseDTO <int> Update(UserRequestDTO request)
{
request.User = request.User == null ? new UserDTO(request.Info.IdUser) : request.User;
request.Info = request.Info == null ? new InfoDTO() : request.Info;
request.User.Password = !string.IsNullOrEmpty(request.User.Password)? HashEncryption.Hash(request.User.Password):null;
return(_userRequestRepository.Update(request));
}
public void Update(Guid?id, UserRequestDTO request)
{
var entity = _userRepository.Get(id.GetValueOrDefault())
.SingleOrDefault() ?? throw new EntityNotFoundException($"User ({id})");
Mapper.Map(request, entity);
_userRepository.Update(entity);
}
public IActionResult Authentificate([FromBody] UserRequestDTO user)
{
var result = _userService.Authentificate(user);
if (result == null)
{
return(BadRequest(new { Message = "Username or Password is invalid!" }));
}
return(Ok(result));
}
public async Task CreateUser(UserRequestDTO userRequest)
{
var requestClient = JsonSerializer.Serialize <UserRequestDTO>(userRequest);
HttpContent content = new StringContent(requestClient, Encoding.UTF8, "application/json");
var httpResponse = await _httpClient.PostAsync($"{_configure.Url}User", content);
if (!httpResponse.IsSuccessStatusCode)
{
throw new Exception("Cannot retrieve tasks");
}
}
public HttpResponseMessage Post(UserRequestDTO loginDTO)
{
if (loginDTO != null)
{
var user = _userServices.GetUserLogin(loginDTO.loginUsername, loginDTO.loginPassword);
if (user != null)
{
return(Request.CreateResponse(HttpStatusCode.OK, user));
}
}
return(Request.CreateErrorResponse(HttpStatusCode.Unauthorized, "No user found matching supplied data"));
}
/// <summary>
/// Invoca AddUser api rest.
/// </summary>
/// <param name="data">UserRequestDTO</param>
/// <returns></returns>
public ResponseDTO <int> AddUser(UserRequestDTO data)
{
var request = new RequestDTO <UserRequestDTO>()
{
IdWebSite = Key.GetIdApp(),
Signature = data,
Token = "admin"
};
response = restClient.Call(request, Key.GetUserAdd()).Result;
return(response);
}
public UserResponseDTO Authenticate(UserRequestDTO model)
{
var user = _userRepository.FindByCredentials(model.Username, model.Password);
if (user == null)
{
return(null);
}
var token = GenerateUserJwtToken(user);
return(new UserResponseDTO(user, token));
}
public async Task CreateTeacher(TeacherRequestDTO request)
{
var teacher = new Teacher(request.Name, request.CPF);
await _teacherRepository.Create(teacher);
var user = new UserRequestDTO()
{
EmailLogin = request.EmailLogin,
Name = request.Name,
Role = (int)Roles.Docente,
};
await _userService.Create(user);
}
public UserResponseDTO Authentificate(UserRequestDTO userRequest)
{
var user = _context.Users.SingleOrDefault(x => x.Email == userRequest.Email && x.Password == userRequest.Password);
if (user == null)
{
return(null);
}
var token = GenerateUserJWTToken(user);
return(new UserResponseDTO(user, token));
}
public UserResponseDTO Authentificate(UserRequestDTO model)
{
var user = _users.SingleOrDefault(x => x.Username == model.Username && x.Password == model.Password);
if (user == null)
{
return(null);
}
var token = GenerateUserJWTToken(user);
return(new UserResponseDTO(user, token));
}
public async Task <IActionResult> Authenticate(UserRequestDTO userRequest)
{
if (ModelState.IsValid)
{
var login = await _userService.Login(userRequest);
if (!login)
{
throw new Exception("Login fail");
}
}
return(RedirectToAction("Index"));
}
public ActionResult CreateUser(UserRequestDTO user)
{
var userService = Factory.InstantiateUserService();
var operationResult = userService.CreateUser(user);
if (operationResult.HasSucceeded)
{
return(Ok());
}
return(BadRequest(operationResult.Exception.Message));
}
public object UpdateUser([FromBody] UserRequestDTO userData)
{
string token = Request.Headers.Authorization == null ? "" : Request.Headers.Authorization.ToString();
Logger.Info(Request.RequestUri + " || Method: " + Request.Method, Request.Headers.ToString(), JsonConvert.SerializeObject(userData), Level.INFO);
ResponseDTO Response = new ResponseDTO();
ErrorDTO ErrorResponse = new ErrorDTO();
UserResponseDTO UserResponse = new UserResponseDTO();
Response = UserBUS.AddOrUpdateUser(userData);
return(Response);
}
public async Task <IActionResult> Authenticate([FromBody] UserRequestDTO userRequest)
{
UserResponseDTO userData;
try
{
userData = await _userService.Authenticate(userRequest);
}
catch (Exception ex)
{
return(CreateServerErrorResponse(ex, null));
}
return(CreateResponse(userData));
}
public async Task Update(UserRequestDTO request)
{
if (_userRepository.EntityExists(request.Id))
{
var user = await _userRepository.GetById(request.Id);
user.Update(request.Name, request.EmailLogin, request.Password, request.Role, request.Active);
await _userRepository.Update(user.Id, user);
}
else
{
_notifications.AddNotification("NotFound", "O estudante informado não existe!");
}
return;
}
public UserResponseDTO CreateUser(UserRequestDTO request)
{
var result = new UserResponseDTO();
var response = this.userDomainService.CreateUser(new Domain.Contract.DomainUserRequestDTO()
{
Email = request.Email, NewPassword = request.NewPassword, LanguageCode = request.LanguageCode
});
result.Header = new ResponseHeader()
{
ResponseCode = response.ResponseCode,
Message = response.Message,
Status = response.Status
};
return(result);
}
public async Task <UserResponseDTO> Authenticate(UserRequestDTO userRequest)
{
var userAuthenticate = new UserResponseDTO();
var user = _mapper.Map <User>(userRequest);
var getUser = await _userRepository.Get(user);
if (getUser == null)
{
throw new Exception("Usuário ou senha incorretos.");
}
userAuthenticate.Token = await _tokenService.GenerateToken(getUser);
userAuthenticate.User = _mapper.Map <UserDTO>(getUser);
return(userAuthenticate);
}
public async Task <PageResult <UserResponseDTO> > Query([FromBody] UserRequestDTO input)
{
string likevalue = $"%{input.Name}%";
string likeaccount = $"%{input.Account}%";
var query = pcontext.User.Where(u => !u.IsSystemAdmin).Where(u => EF.Functions.Like(u.Name, likevalue)).Where(u => EF.Functions.Like(u.Account, likeaccount))
.Select(u => new UserResponseDTO
{
Id = u.Id,
Account = u.Account,
Name = u.Name,
CreateTime = u.CreateTime
});
var count = await query.CountAsync();
var data = await query.Skip((input.PageIndex - 1) *input.PageSize).Take(input.PageSize)
.ToListAsync();
return(new PageResult <UserResponseDTO>(count, data));
}
public UserResponseDTO InsertUser(UserRequestDTO data)
{
var resultGuid = Guid.NewGuid();
try
{
var resultMailExist = VerifyUserExist(data, out _response);
if (!resultMailExist)
{
if (_userRepository.InsertUser(new UserRequestDTO
{
email = data.email,
codeIn = EncodeDecode.CrashIn(data.codeIn),
nickName = data.nickName
}, resultGuid.ToString(), EncodeDecode.CrashIn(data.codeIn)) == 1)
{
_response.guid = resultGuid.ToString();
_response.hasSuccess = true;
_response.logged = true;
_response.statusCode = System.Net.HttpStatusCode.OK;
_response.message = "Usuário cadastrado com sucesso!";
}
else
{
_response.guid = null;
_response.hasSuccess = false;
_response.logged = false;
_response.statusCode = System.Net.HttpStatusCode.Unauthorized;
_response.message = "Erro ao cadastrar usuário!";
}
}
}
catch (Exception ex)
{
_response.guid = null;
_response.hasSuccess = false;
_response.logged = false;
_response.statusCode = System.Net.HttpStatusCode.Unauthorized;
_response.message = "Erro no cadastro de usuários. | " + ex.Message;
}
return(_response);
}
public static CookieHeaderValue SetCookieSession(UserRequestDTO authorizedRequest, string token, HttpRequestMessage request, out string expiresTime, out string sToken)
{
var time = 60;
sToken = string.Empty;
expiresTime = string.Empty;
expiresTime = DateTimeOffset.Now.AddMinutes(time).ToString();
var nv = new NameValueCollection();
nv["Token"] = token;
nv["Expires"] = expiresTime;
sToken = token;
var cookie = new CookieHeaderValue("Authorization", nv);
cookie.Expires = DateTimeOffset.Now.AddMinutes(time);
cookie.Domain = request.RequestUri.Host;
cookie.Path = "/";
return(cookie);
}
