public async Task <IActionResult> Login([FromBody] LoginDto loginDto)
{
var user = await userManager.FindByEmailAsync(loginDto.Email);
if (user == null)
{
return(BadRequest("Invalid username or password"));
}
var result = await signInManager.CheckPasswordSignInAsync(user, loginDto.Password, false);
ClaimsIdentity identity = await authService.GetClaimsIdentity(user);
if (result.Succeeded)
{
var roles = await userManager.GetRolesAsync(user);
var loginResponseDto = new LoginResponseDto
{
FirstName = user.FirstName,
LastName = user.LastName,
FullName = user.FullName,
Email = user.Email,
Roles = roles,
Address = user.Address,
Token = authService.GenerateToken(identity)
};
return(Ok(loginResponseDto));
}
return(BadRequest("Invalid username or password"));
}
public async Task <object> Login([FromBody] LoginDto loginDto, [FromServices] ILoginService service)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState)); // Erro 400 Bad Request
}
if (loginDto == null)
{
return(BadRequest()); // Erro 400 Bad Request
}
try
{
LoginResponseDto result = await service.FindByLoginAsync(loginDto.Email);
if (result != null)
{
return(result); // Req 200
}
else
{
return(NotFound()); // Error 404 Not found
}
}
catch (ArgumentException e)
{
return(StatusCode((int)HttpStatusCode.InternalServerError, e.Message)); //Erro 500
}
}
public void LoginRequest(PacketHeader packetHeader, Connection connection, LoginDto incomingObject)
{
Console.WriteLine("\nLogin request received..");
//response
var loginResponseDto = new LoginResponseDto();
// getting requested user
User user = userRepository
.GetAllByCondition(x => x.Name == incomingObject.Login)
.FirstOrDefault();
if (user == null)
{
UserNotFoundMethod(connection, loginResponseDto);
}
if (!String.Equals(user.Password, incomingObject.Password))
{
WrongPasswordMethod(connection, loginResponseDto);
}
Console.WriteLine("Login request successful:");
Console.WriteLine("User: '******' logged to a server.", incomingObject.Login);
loginResponseDto.Key = dummyAuthentication.AddUser(user.UserId);
loginResponseDto.Message = "Logging successful.";
connection.SendObject(PacketTypes.Login.Response, loginResponseDto);
}
protected virtual async Task<LoginResponseDto> Create(UserProfileDto input)
{
var rtv = new LoginResponseDto();
input.userPassword = Cryptors.GetSHAHashData(input.userPassword);
input.IsLockoutEnabled = 0;
input.DateCreated = DateTime.Now;
input.userEmail = input.userEmail;
input.ShouldChangePasswordOnNextLogin = 1;
input.AccessFailedCount = 0;
input.businessName = input.businessName;
input.Country = input.Country;
UserProfile userDto = MappingProfile.MappingConfigurationSetups().Map<UserProfile>(input);
_context.UserProfile.Add(userDto);
int res = await _context.SaveChangesAsync();
if (res > 0)
{
rtv.ResponseCode = 0;
rtv.ResponseText = "Successfull";
return rtv;
}
else
{
rtv.ResponseCode = -2;
rtv.ResponseText = "Failed";
return rtv;
}
}
public MasterDetail(LoginResponseDto asociado)
{
InitializeComponent();
this.Master = new Maestro(asociado);
this.Detail = new NavigationPage(new Detalle());
App.MasterD = this;
}
public async Task E_Possivel_Executar_Metodo_FindByLogin()
{
var email = Internet.Email();
LoginResponseDto objRetorno = new LoginResponseDto(
true,
DateTime.UtcNow,
DateTime.UtcNow.AddHours(8),
Guid.NewGuid().ToString(),
Name.FullName(),
"Login efetuado com sucesso."
);
var loginDto = new LoginRequestDto
{
Email = email
};
_serviceMock = new Mock <ILoginService>();
_serviceMock.Setup(m => m.FindByLogin(loginDto)).ReturnsAsync(objRetorno);
_serviceLogin = _serviceMock.Object;
var result = await _serviceLogin.FindByLogin(loginDto);
Assert.NotNull(result);
}
protected virtual async Task<LoginResponseDto> Update(UserProfileDto input)
{
var rtv = new LoginResponseDto();
var users = await _context.UserProfile.Where(x => x.Id == input.Id).FirstOrDefaultAsync();
if (users != null)
{
UserProfile user = new UserProfile
{
userEmail = input.userEmail,
FirstName = input.FirstName,
LastName = input.LastName,
MiddleName = input.MiddleName,
PhoneNumber = input.PhoneNumber,
};
_context.UserProfile.Update(users);
int res = await _context.SaveChangesAsync();
if (res > 0)
{
rtv.ResponseCode = 0;
rtv.ResponseText = "Successfull";
return rtv;
}
}
rtv.ResponseCode = -2;
rtv.ResponseText = "Failed";
return rtv;
}
/// <summary>
/// GetCliams
/// </summary>
/// <param name="loginResponse"></param>
/// <param name="userName"></param>
/// <param name="addExpiryMinutes"></param>
/// <returns></returns>
private Dictionary <string, string> GetClaims(LoginResponseDto loginResponse,
string userName,
int addExpiryMinutes)
{
try
{
Dictionary <string, string> claims = new Dictionary <string, string>();
claims.Add("USERGROUP", string.Join(",", loginResponse.UserGroup ?? new List <string>().ToArray()));
claims.Add("FIRSTNAME", loginResponse.FirstName);
claims.Add("LASTNAME", loginResponse.LastName);
claims.Add(ClaimTypes.Name, userName);
claims.Add(ClaimTypes.Expired, DateTime.Now.AddMinutes(addExpiryMinutes).ToString());
claims.Add(JwtRegisteredClaimNames.Jti, Guid.NewGuid().ToString());
claims.Add("ORGANIZATIONUNITS",
string.Join(",",
loginResponse.OrganizationUnits?.Select(a => a.Code).ToList() ?? new List <string>()));
claims.Add("ORGANIZATIONS",
string.Join(",", loginResponse.Organizations?.Select(a => a.Code).ToList() ?? new List <string>()));
claims.Add("EMAIL", loginResponse.Email);
return(claims);
}
catch (Exception ex)
{
throw ex;
}
}
public async Task <IActionResult> Login(LoginRequestDto loginRequest)
{
if (loginRequest == null)
{
return(StatusCode(StatusCodes.Status400BadRequest, $"Parâmetro '{nameof(loginRequest)}' incorreto."));
}
var user = await userManager.FindByEmailAsync(loginRequest.Email);
if (user == null)
{
return(StatusCode(StatusCodes.Status401Unauthorized, "Email incorreto!"));
}
var result = await signInManager.CheckPasswordSignInAsync(user, loginRequest.Password, false);
if (result.Succeeded)
{
var userDto = mapper.Map <UserDto>(user);
var roles = await userManager.GetRolesAsync(user);
//var token = authService.GenerateJWToken(user).Result;
var token = await new JwtService().GenerateToken(user, roles, config["JWT_SECRET"]);
var response = new LoginResponseDto
{
token = token,
user = userDto
};
return(Ok(response));
}
return(StatusCode(StatusCodes.Status401Unauthorized, "Senha incorreta!"));
}
public async Task <LoginResponseDto> CheckLogin(string username, string encryptedPassword)
{
LoginRequestDto dto = new LoginRequestDto
{
MobileNo = username,
Password = encryptedPassword
};
//IRestClient<LoginRequestDto, LoginResponseDto> rest = new RestClient<LoginRequestDto, LoginResponseDto>();
//LoginResponseDto res = await rest.Post(dto, "Login/CheckLogin", MediaType.Json, Encoding.UTF8);
// Temp Login
LoginResponseDto res = new LoginResponseDto()
{
Message = "success",
Name = "Emp1",
Status = true,
UserId = 100
};
if (res.Status)
{
// Save in Shared Preferance.
SharedPreferences.UserId = res.UserId;
UpdateNotificationToken();
}
return(res);
}
public async Task <ActionResult <LoginResponseDto> > ConfirmSocialLogin([FromBody] SocialLoginDto model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var user = await _userService.GetUserByEmail(model.Email);
if (user != null)
{
var token = GenerateToken(user.User);
var loginResult = new LoginResponseDto();
loginResult.Token = new JwtSecurityTokenHandler().WriteToken(token);
loginResult.User = user.User;
loginResult.CreatedDebates = user.CreatedDebates;
loginResult.ParticipatingDebates = user.ParticipatingDebates;
return(Ok(loginResult));
}
else
{
bool created = await _userService.Register(model.Email);
if (!created)
{
return(BadRequest("Unable to create user"));
}
user = await _userService.GetUserByEmail(model.Email);
var token = GenerateToken(user.User);
var loginResult = new LoginResponseDto();
loginResult.Token = new JwtSecurityTokenHandler().WriteToken(token);
loginResult.User = user.User;
return(Created("/auth/social", loginResult));
}
}
public async Task <ActionResult <LoginResponseDto> > Login([FromBody] LoginRegisterDto model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var user = await _userService.Login(model);
if (user == null)
{
return(BadRequest("Unable to login"));
}
var token = GenerateToken(user.User);
var loginResult = new LoginResponseDto();
loginResult.Token = new JwtSecurityTokenHandler().WriteToken(token);
loginResult.User = user.User;
loginResult.CreatedDebates = user.CreatedDebates;
loginResult.ParticipatingDebates = user.ParticipatingDebates;
return(Ok(loginResult));
}
public async Task <IActionResult> Login(LoginDto dto)
{
var user = await _userManager.FindByNameAsync(dto.UserName);
if (user != null && await _userManager.CheckPasswordAsync(user, dto.Password))
{
var tokenDescriptor = new SecurityTokenDescriptor
{
Subject = new ClaimsIdentity(await GetValidClaims(user)),
Expires = DateTime.UtcNow.AddDays(1),
SigningCredentials = new SigningCredentials(
new SymmetricSecurityKey(Encoding.UTF8.GetBytes(_configuration.GetValue <string>("AppSecret"))),
SecurityAlgorithms.HmacSha256Signature)
};
var tokenHandler = new JwtSecurityTokenHandler();
var securityToken = tokenHandler.CreateToken(tokenDescriptor);
var token = tokenHandler.WriteToken(securityToken);
var response = new LoginResponseDto()
{
Token = token
};
return(Ok(response));
}
return(BadRequest(new { message = "Username or password is incorrect" }));
}
public async Task <ServiceResponse <LoginResponseDto> > Login(LoginUserDto loginUserDto)
{
var serviceResponse = new ServiceResponse <LoginResponseDto>();
var user = await _context.Users.SingleOrDefaultAsync(u => u.Email == loginUserDto.Email);
if (user == null)
{
serviceResponse.Success = false;
serviceResponse.Message = "Invalid Credentials";
return(serviceResponse);
}
var validPassword = BCrypt.Net.BCrypt.Verify(loginUserDto.Password, user.PasswordHash);
if (!validPassword)
{
serviceResponse.Success = false;
serviceResponse.Message = "Invalid Credentials";
return(serviceResponse);
}
var token = _jwtGenerator.GenerateToken(user);
var response = new LoginResponseDto
{
Id = user.Id,
AccessToken = token
};
serviceResponse.Data = response;
return(serviceResponse);
}
public LoginResponseDto Login(LoginDto dto)
{
var result = new LoginResponseDto();
dto.Password = FunctionCommon.GetMd5(FunctionCommon.GetSimpleMd5(dto.Password));
var accountFromDb = db.Accounts.FirstOrDefault(x => x.UserName == dto.UserName && x.Password == dto.Password && !x.DelFlag);
if (accountFromDb == null)
{
return null;
}
var isStudent = db.AccountGroups.FirstOrDefault(x => !x.DelFlag && x.Name.ToLower().Equals("Sinh viên")).Id == accountFromDb.AccountGroupId;
var accessToken = JwtAuthenticationExtensions.CreateToken(accountFromDb, isStudent);
result.AccessToken = accessToken;
result.FirstName = accountFromDb.UserInfo.FirstName;
result.LastName = accountFromDb.UserInfo.LastName;
result.Avatar = accountFromDb.Avatar;
result.UserName = accountFromDb.UserName;
result.IsStudent = isStudent;
return result;
}
public async Task <LoginResponseDto> FindByLogin(LoginRequestDto requestDto)
{
var response = new LoginResponseDto(false, "Falha ao autenticar");
if (requestDto != null && !string.IsNullOrWhiteSpace(requestDto.Email))
{
UserEntity entity = await _repository.FindByLogin(requestDto.Email);
if (entity == null)
{
return(response);
}
var identity = new ClaimsIdentity(
new GenericIdentity(entity.Email),
new []
{
new Claim(JwtRegisteredClaimNames.Jti, Guid.NewGuid().ToString()),
new Claim(JwtRegisteredClaimNames.UniqueName, entity.Email),
}
);
DateTime createDate = DateTime.Now;
DateTime expirationDate = createDate + TimeSpan.FromSeconds(Convert.ToDouble(Environment.GetEnvironmentVariable("Seconds")));
var handler = new JwtSecurityTokenHandler();
string token = CreateToken(identity, createDate, expirationDate, handler);
return(SuccessObject(createDate, expirationDate, token, requestDto));
}
return(response);
}
private async Task ReceiveLoginResponse(LoginResponseDto loginResponse)
{
await SetRefreshToken(loginResponse.RefreshToken);
AccessToken = loginResponse.AccessToken;
this.user = loginResponse.User;
await mainContext.UI.GoToRideOverviewScreenAsync();
}
/// <summary>Invoca al Procedimiento almacenado que lista Usuarios.</summary>
/// <param name="objFiltro">Parámetros para el filtro de Listar las Usuarios</param>
///<remarks>
///<list type = "bullet">
///<item><CreadoPor>Bryan Luna Vasquez.</CreadoPor></item>
///<item><FecCrea>19/02/2018</FecCrea></item></list>
///<list type="bullet">
/// <item><FecActu>XX/XX/XXXX.</FecActu></item>
/// <item><Resp>Responsable.</Resp></item>
/// <item><Mot>Motivo.</Mot></item></list></remarks>
public static LoginResponseDto Login(LoginRequestDto request)
{
try
{
LoginResponseDto response;
LoginListaDto objLogin;
ArchivoListaDto objArchivo;
List <OpcionListaDto> listaOpcionesPerfil;
Campania objCampaniaActual;
DatosUsuarioListaDto objDatosUsuario;
string usuario;
string clave;
string campania;
usuario = request.Usuario;
clave = request.Clave;
objLogin = UsuarioData.Login(usuario);
if (objLogin == null)
{
BusinessException.Generar(Constantes.Mensajes.USUARIO_NO_EXISTE);
}
if (objLogin.Clave != Funciones.Encriptar(clave.ToUpper()))
{
BusinessException.Generar(Constantes.Mensajes.CLAVE_USUARIO_INCORRECTA);
}
objDatosUsuario = UsuarioData.ListarDatosUsuario(objLogin.Codigo);
objDatosUsuario.Codigo = objLogin.Codigo;
objDatosUsuario.Clave = objLogin.Clave;
objDatosUsuario.CodigoEdificio = objLogin.CodigoEdificio;
objDatosUsuario.CodigoPerfil = objLogin.CodigoPerfil;
objDatosUsuario.CodigoPersona = objLogin.CodigoPersona;
objDatosUsuario.Nombre = objLogin.Nombre;
objDatosUsuario.Usuario = objLogin.Usuario;
objCampaniaActual = CampaniaData.ObtenerCampaniaActual((int)objDatosUsuario.CodigoEdificio);
campania = objCampaniaActual.Codigo;
objDatosUsuario.CampaniaActual = campania;
listaOpcionesPerfil = OpcionData.ListaOpcionesPorPerfil(objLogin.CodigoPerfil);
response = new LoginResponseDto
{
ListaOpcionesPorPerfil = listaOpcionesPerfil,
Usuario = objDatosUsuario,
//FotoUsuario = objArchivo,
};
return(response);
}
catch (Exception ex)
{
Log.RegistrarLog(NivelLog.Error, ex);
throw;
}
}
public RegistrarTransporte(LoginResponseDto aso, Transporte transpor)
{
InitializeComponent();
asociado = aso;
transporte = transpor;
if (transpor.id != "0")
{
llenarDatosDiaControl();
}
}
public RegistrarCompra(LoginResponseDto aso, Compra comp)
{
InitializeComponent();
asociado = aso;
compra = comp;
if (comp.id != "0")
{
llenarDatosDiaControl();
}
}
private async Task <LoginResponseDto> GerarJwt(string email)
{
//recuperando dados do user para colocar no token
var user = await _userManager.FindByEmailAsync(email);
var claims = await _userManager.GetClaimsAsync(user);
var userRoles = await _userManager.GetRolesAsync(user);
claims.Add(new Claim(JwtRegisteredClaimNames.Sub, user.Id));
claims.Add(new Claim(JwtRegisteredClaimNames.Email, user.Email));
claims.Add(new Claim(JwtRegisteredClaimNames.Jti, Guid.NewGuid().ToString()));
claims.Add(new Claim(JwtRegisteredClaimNames.Nbf, ToUnixEpochDate(DateTime.UtcNow).ToString()));
claims.Add(new Claim(JwtRegisteredClaimNames.Iat, ToUnixEpochDate(DateTime.UtcNow).ToString(), ClaimValueTypes.Integer64));
foreach (var userRole in userRoles)
{
claims.Add(new Claim("role", userRole));
}
var identityClaims = new ClaimsIdentity();
identityClaims.AddClaims(claims);
//passando dados para o token
var tokenHandler = new JwtSecurityTokenHandler();
var key = Encoding.ASCII.GetBytes(_appSettings.Secret);
var token = tokenHandler.CreateToken(new SecurityTokenDescriptor
{
Issuer = _appSettings.Emissor,
Audience = _appSettings.ValidoEm,
Subject = identityClaims,
Expires = DateTime.UtcNow.AddHours(_appSettings.ExpiracaoHoras),
SigningCredentials = new SigningCredentials(new SymmetricSecurityKey(key), SecurityAlgorithms.HmacSha256Signature)
});
var encodedToken = tokenHandler.WriteToken(token);
//preparando o dados para o response
var response = new LoginResponseDto
{
AccessToken = encodedToken,
ExpiresIn = TimeSpan.FromHours(_appSettings.ExpiracaoHoras).TotalSeconds,
UserToken = new UserTokenDto
{
Id = user.Id,
Email = user.Email,
Claims = claims.Select(c => new ClaimDto {
Type = c.Type, Value = c.Value
})
}
};
//response
return(response);
}
public ActionResult Authenticate(LoginModel model)
{
LoginResponseDto response = service.Authenticate(model.Username, model.Password);
if (response.Error != null)
{
return(BadRequest(response));
}
return(Ok(response));
}
public RegistrarCosecha(LoginResponseDto aso, Cosecha cose, string idCultivo)
{
InitializeComponent();
asociado = aso;
cosecha = cose;
cultivoId = idCultivo;
if (cosecha.id != "0")
{
llenarDatosCultivo();
}
}
public async Task <LoginResponseDto> Authenticate(LoginRequestDto rq)
{
var sr = new ServiceResponse();
var response = new LoginResponseDto();
var secretKey = _configuration.GetValue <string>("SecretKey");
var key = Encoding.ASCII.GetBytes(secretKey);
try
{
var user = await _repositoryAuth.Authenticate(rq);
if (user == null || user.IsDelete || user.IsLocked)
{
sr.AddError("El usuario no existe o se encuentra bloqueado");
return(response);
}
var tokenDescriptor = new SecurityTokenDescriptor
{
Subject = new ClaimsIdentity(new Claim[] {
new Claim("id", user.Id.ToString()),
new Claim("email", user.Email),
new Claim("idRol", user.Rol.Id.ToString())
}),
Expires = DateTime.Now.AddDays(1),
SigningCredentials = new SigningCredentials(new SymmetricSecurityKey(key), SecurityAlgorithms.HmacSha256Signature)
};
var tokenHandler = new JwtSecurityTokenHandler();
var tokenCreated = tokenHandler.CreateToken(tokenDescriptor);
var token = tokenHandler.WriteToken(tokenCreated);
var result = new LoginResponseDto
{
Id = user.Id,
Name = user.Name,
Surname = user.Surname,
Email = user.Email,
Rol = _mapper.Map <RolDto>(user.Rol),
Token = token
};
//sr.Data = response;
response = result;
}
catch (Exception ex)
{
sr.AddError(ex);
}
return(response);
}
public GestionarDiaControl(LoginResponseDto aso, string idCultivo, DiaControl dia)
{
InitializeComponent();
asociado = aso;
diaControl = dia;
cultivoId = idCultivo;
if (diaControl.id != "0")
{
llenarDatosDiaControl();
}
}
public GestionarCompras(LoginResponseDto aso)
{
InitializeComponent();
asociado = aso;
llenaLista();
compra_lv.RefreshCommand = new Command(() =>
{
llenaLista();
compra_lv.IsRefreshing = false;
});
}
public ModalNiames(LoginResponseDto aso, RegistrarTransporte root)
{
InitializeComponent();
asociado = aso;
_root = root;
llenaLista();
niames_lv.RefreshCommand = new Command(() =>
{
llenaLista();
niames_lv.IsRefreshing = false;
});
}
private LoginResponseDto SuccessObject(string name, DateTime createDate, DateTime expirationDate, string token, string email)
{
LoginResponseDto loginResponseDtoSuccess = new LoginResponseDto();
loginResponseDtoSuccess.Name = name;
loginResponseDtoSuccess.Authenticated = true;
loginResponseDtoSuccess.CreateAt = createDate;
loginResponseDtoSuccess.Expiration = expirationDate;
loginResponseDtoSuccess.Token = token;
loginResponseDtoSuccess.Email = email;
loginResponseDtoSuccess.Message = "Usuário logado com sucesso";
return(loginResponseDtoSuccess);
}
public ModalImsumoCompra(LoginResponseDto aso, RegistrarCompra root)
{
InitializeComponent();
asociado = aso;
_root = root;
llenaLista();
insumos_lv.RefreshCommand = new Command(() =>
{
llenaLista();
insumos_lv.IsRefreshing = false;
});
}
public GestionarAsociadosRequest(LoginResponseDto aso)
{
InitializeComponent();
asociado = aso;
llenaLista();
solicitudes_lv.RefreshCommand = new Command(() =>
{
llenaLista();
solicitudes_lv.IsRefreshing = false;
});
}
