public async Task <HttpResponseMessage> SendEmailConfirmLink([FromBody] EmailDTO emailModel, string emailConfirmLink)
{
try
{
if (emailConfirmLink == null)
{
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, "Email confirmation link not found"));
}
if (ModelState.IsValid)
{
var user = userService.GetByEmail(emailModel.Email);
if (user == null)
{
return(Request.CreateErrorResponse(HttpStatusCode.NoContent, "User not found"));
}
if (user.EmailConfirmed)
{
return(Request.CreateErrorResponse(HttpStatusCode.Forbidden, "Email already confirmed"));
}
string token = JwtManager.GenerateToken(user, 0, 1);
await EmailService.SendConfirmPasswordEmail(user.Email, token, emailConfirmLink);
return(Request.CreateResponse(HttpStatusCode.OK, "Token successfully sent"));
}
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, "Email is not valid"));
}
catch (EntityException e)
{
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, e));
}
}
public IHttpActionResult Get(string username, string password)
{
JwtResult objJwtResult = new JwtResult();
try
{
UsuarioService usuarioService = new UsuarioService();
Usuario usuario = usuarioService.ObterPorLogin(username);
if (usuario != null && EncriptarSenha.CompararSenhas(password, usuario.Senha))
{
string token = JwtManager.GenerateToken(usuario.IdUsuario.ToString());
objJwtResult.access_token = token;
return(Ok(objJwtResult));
}
else
{
return(Unauthorized());
}
}
catch (Exception erro)
{
return(BadRequest(erro.Message));
}
}
public HttpResponseMessage SignIn([FromBody] UserDetailsModel userDetailsModel)
{
try
{
if (string.IsNullOrEmpty(userDetailsModel.UserName) || string.IsNullOrEmpty(userDetailsModel.Password))
{
return(Request.CreateResponse(HttpStatusCode.BadRequest, "Username or Password can not be empty", Configuration.Formatters.JsonFormatter));
}
var userDetails = Mapper.Map <UserDetailsModel, ContactInfo.DBEntities.Entities.UserDetail>(userDetailsModel);
bool status = _accountBL.SignIn(userDetails);
if (!status)
{
return(Request.CreateResponse(HttpStatusCode.Unauthorized, "Invalid User", Configuration.Formatters.JsonFormatter));
}
else
{
string token = JwtManager.GenerateToken(userDetails.UserName);
return(Request.CreateResponse(HttpStatusCode.OK, token, Configuration.Formatters.JsonFormatter));
}
}
catch (Exception ex)
{
return(Request.CreateResponse(HttpStatusCode.InternalServerError, "Internal Server Error", Configuration.Formatters.JsonFormatter));
}
}
public IHttpActionResult Login(Models.Login loginReqest)
{
try
{
if (loginReqest == null)
{
return(Content(HttpStatusCode.BadRequest, new Response <string>("400", "Request should not be null")));
}
else if (!ModelState.IsValid)
{
return(Content(HttpStatusCode.BadRequest, new Response <string>("400", "This feild is mandatory", null, ModelState)));
}
var user = new User();
if (loginReqest.U_Email != null)
{
string query = "SELECT * FROM AppUser where U_Email= @userEmail";
SqlConnection conn = new SqlConnection(Utils.connStr);
SqlCommand command = new SqlCommand(query, conn);
command.Parameters.AddWithValue("@userEmail", loginReqest.U_Email);
conn.Open();
SqlDataReader reader = command.ExecuteReader();
if (reader.Read())
{
user = new User()
{
U_ID = (int)reader["U_ID"],
U_Name = reader["U_Name"].ToString(),
U_Email = reader["U_Email"].ToString(),
U_Password = reader["U_Password"].ToString(),
};
}
else
{
conn.Close();
return(Content(HttpStatusCode.BadRequest, new Response <string>("400", "Email or Password dosen't match.")));
}
conn.Close();
if (user.U_Email != null)
{
var auth = BCrypt.Net.BCrypt.Verify(loginReqest.U_Password, user.U_Password);
if (auth)
{
var token = JwtManager.GenerateToken(user);
user.Token = token;
return(Content(HttpStatusCode.OK, new Response <User>("200", "Login Succesfully.", user)));
}
else
{
return(Content(HttpStatusCode.BadRequest, new Response <string>("400", "Email or Password doesn't match.")));
}
}
}
}
catch (Exception ex)
{
return(Content(HttpStatusCode.InternalServerError, new Response <string>(ex.StackTrace, ex.Message)));
};
return(Content(HttpStatusCode.InternalServerError, new Response <string>("500", "Something went wrong.Please try again later.")));
}
private void SendMail(int userId, int sid, out string token)
{
string email = db.User.Where(x => x.UserId == userId)
.Select(x => x.Email).FirstOrDefault();
EmailManager.SendMail(email, $"Your conformation code is: {sid}", "Confirm your identity");
token = JwtManager.GenerateToken(userId, role: "notUser");
}
public IHttpActionResult Post([FromBody] AuthUser user)
{
var result = JwtManager.GenerateToken(user);
// var result = JwtManager.GenerateToken(user.UserName, user.UserRole);
return(Ok(result));
}
private async Task <TokenDTO> GenerateNewTokensAsync(User user)
{
var role = await _unitOfWork.RoleRepository.GetAsync(user.RoleId);
var token = _jwtManager.GenerateToken(user.Id, user.Email, role?.Name);
return(token);
}
public string Get(string username, string password)
{
if (CheckUser(username, password))
{
return(JwtManager.GenerateToken(username));
}
throw new HttpResponseException(HttpStatusCode.Unauthorized);
}
public void TestMethod1()
{
//Run
var result = JwtManager.GenerateToken("nhonnt");
//Asert
Assert.AreEqual(new TimeSpan(4, 30, 0).ToString(), result);
}
public HttpResponseMessage GetToken(string username, string password)
{
if (CheckUser(username, password))
{
return(Request.CreateResponse(HttpStatusCode.OK, JwtManager.GenerateToken(username)));
}
return(Request.CreateResponse(HttpStatusCode.Unauthorized));
}
public TokenModule() : base(@"/api")
{
Get(@"/token/{user}", parameters =>
{
string user = parameters.user;
var token = JwtManager.GenerateToken(user);
return(Response.AsJson(token));
});
}
public string Login([FromBody] Models.User user)
{
if (CheckUser(user.Username, user.Password, out Models.User loginUser))
{
return(JwtManager.GenerateToken(loginUser));
}
throw new HttpResponseException(HttpStatusCode.Unauthorized);
}
public void JwtGenerateToken_Success()
{
var token = JwtManager.GenerateToken("user_test");
if (token.Length > 0)
{
Assert.True(true);
}
}
public IHttpActionResult Get([FromBody] User user)
{
if (CheckUser(user.name, user.password))
{
return(Ok <string>(JwtManager.GenerateToken(user.name)));
}
throw new HttpResponseException(HttpStatusCode.Unauthorized);
}
public async Task <UserInfo> Login(SignInDto dto)
{
var userInfo = await new LoginCommand(dto).Login();
userInfo.Token = JwtManager.GenerateToken(userInfo, out var expiresOn, 180, userInfo.CompanyId);
userInfo.ExpiresOn = expiresOn;
return(userInfo);
}
public void JwtValidateDate(int minutesCount)
{
Constants.JwtExpiryInMinutes = minutesCount;
var token = JwtManager.GenerateToken(user);
var dateTo = DateTime.UtcNow.AddMinutes(minutesCount);
Assert.IsTrue(Math.Abs((dateTo - token.ValidTo).TotalSeconds) < 3);
}
public async Task <IHttpActionResult> LoginFb([FromBody] LoginViewModel request)
{
var user = ApplicationUserManager.FindByName(request.Email);
if (user == null)
{
user = new User()
{
UserName = request.Email,
Email = request.Email,
FirstName = request.Firstname,
LastName = request.Lastname,
FacebookId = request.Type.Equals("fb") ? request.Uid : "",
GoogleId = request.Type.Equals("gg") ? request.Uid : "",
};
IdentityResult result = await ApplicationUserManager.CreateAsync(user);
if (!result.Succeeded)
{
return(BadRequest("Can't create user"));
}
string fileName = user.Id + DateTime.Now.Millisecond.ToString() + ".jpg";
string filePath = HttpContext.Current.Server.MapPath("~/Media/UserImage/") + fileName;
Utilities.GetImageFormUrl(request.Avatar).Save(filePath);
user.ImageUrl = "/Media/UserImage/" + fileName;
result = await ApplicationUserManager.UpdateAsync(user);
}
request.Status_code = "200";
request.Message = "OK";
request.AccessToken = JwtManager.GenerateToken(user.UserName, expried);
request.Avatar = user.ImageUrl;
request.Email = user.Email;
request.Uid = user.Id;
request.Lastname = user.LastName;
request.Amount = user.Current_Money;
request.Phone = user.PhoneNumber;
request.Bio = user.FirstName;
request.Tknl = user.TKNL;
if (user.Address != null)
{
string[] abc = user.Address.Split('_');
if (abc.Length == 2)
{
City city = cityService.GetCities().FirstOrDefault(c => c.Code.Equals(abc[1]));
if (city != null)
{
request.Address = abc[0] + ", " + city.Name + ", " + city.Country.Name;
request.GeoId = abc[1];
}
}
}
return(Ok(request));
}
public IHttpActionResult GetToken([FromBody] UserCredentials userCredentials)
{
if (_userLogic.ValidateCredentials(userCredentials))
{
return(Ok(JwtManager.GenerateToken(userCredentials.Login)));
}
return(StatusCode(HttpStatusCode.Unauthorized));
}
public User Post([FromBody] User user)
{
if (this.CheckUser(user))
{
user.JWtToken = JwtManager.GenerateToken(user.UserName);
return(user);
}
throw new HttpResponseException(HttpStatusCode.Unauthorized);
}
public string GenerateToken(string username, string password)
{
Enums.UserType role;
if (CheckUser(username, password, out role))
{
return(JwtManager.GenerateToken(username, role.ToString()));
}
throw new HttpResponseException(HttpStatusCode.Unauthorized);
}
public IActionResult UpdateAuthToken()
{
if (CurrentUser.IsEnabled && CurrentUser.EmailConfirmed)
{
var token = JwtManager.GenerateToken(CurrentUser);
return(Ok(token.Value));
}
return(BadRequest(ErrorResult.GetResult(ValidationMessages.AccessDenied)));
}
public string Get(string mail, string mot_de_passe)
{
if (CheckUser(mail, mot_de_passe))
{
return(JwtManager.GenerateToken(mail));
}
//throw new HttpResponseException(HttpStatusCode.Unauthorized);
return("error");
}
public UserViewModel MapUser(UserModel model)
{
return(new UserViewModel
{
Id = model.Id,
Email = model.Email,
HandleName = (model.HandleName.Length > 0) ? model.HandleName : model.Email,
token = JwtManager.GenerateToken(model.Email)
});
}
public string Post([FromBody]User user)
{
if (CheckUser(user.Username, user.Password))
{
var token = JwtManager.GenerateToken(user.Username);
return token;
}
throw new System.Web.Http.HttpResponseException(System.Net.HttpStatusCode.Unauthorized);
}
[IdentityBasicAuthentication] // Enable Basic authentication for this action.
//[BasicAuthenticationFilter]
public string Post(string username, string password)
{
_log.Debug("Entra");
if (new UsuarioRepository().ExisteUsuario(username, password))
{
return(JwtManager.GenerateToken(username));
}
throw new HttpResponseException(HttpStatusCode.Unauthorized);
}
public async Task <Token> GenerateToken(int userId)
{
var user = await userManager.FindByIdAsync(userId);
if (user != null && user.Id > 0)
{
return(JwtManager.GenerateToken(await userManager.CreateIdentityAsync(user)));
}
return(null);
}
public async Task <AuthResult <Token> > Login(LoginDTO loginDto)
{
if (loginDto == null || string.IsNullOrEmpty(loginDto.Email) || string.IsNullOrEmpty(loginDto.Password))
{
return(AuthResult <Token> .UnvalidatedResult);
}
var user = await userManager.FindByEmailAsync(loginDto.Email);
if (user != null && user.Id > 0)
{
if (await userManager.CheckPasswordAsync(user, loginDto.Password))
{
var token = jwtManager.GenerateToken(user);
return(AuthResult <Token> .TokenResult(token));
}
}
return(AuthResult <Token> .UnauthorizedResult);
}
public void TryAndGeneratingTokenWithNegativeExpiry()
{
Assert.That(() =>
{
JwtManager.GenerateToken("test", -10);
}, Throws.Exception
.TypeOf <ArgumentOutOfRangeException>()
.With.Property("Message")
.StartsWith("The value of minutes to expire cannot be less then or equal to zero.")
);
}
public string Get()
{
if (Thread.CurrentPrincipal.Identity.IsAuthenticated)
{
return(JwtManager.GenerateToken(Thread.CurrentPrincipal.Identity.Name));
}
else
{
throw new HttpResponseException(HttpStatusCode.Unauthorized);
}
}
public IHttpActionResult Login(LoginViewModel model)
{
var user = _userService.Login(model.UserName, model.Password);
if (user != null)
{
return(Ok(JwtManager.GenerateToken(user.UserName)));
}
return(this.Unauthorized());
}
