public IHttpActionResult LoginCheck(string email = "", string password = "")
{
string token = Guid.NewGuid().ToString();
Users user = dm.Users.Where(x => x.Email == email && x.Pass == password).FirstOrDefault();
if (user != null)
{
AuthVM auth = new AuthVM()
{
UserID = user.UserID,
Email = user.Email,
//Password = user.Pass,
Token = token,
ExpiresIn = 3600
};
dm.AuthTokens.Add(new AuthTokens
{
Token = auth.Token,
UserID = auth.UserID,
IPAddress = "...",
});
dm.SaveChanges();
return(Ok(auth));
}
else
{
return(NotFound());
}
}
public async Task <IActionResult> Login([FromBody] AuthVM authVM)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState)); //retruns model state error
}
var result = await _signInManager.PasswordSignInAsync(
userName : authVM.Username,
password : authVM.Password,
isPersistent : true,
lockoutOnFailure : true);
if (result.Succeeded)
{
var user = _userManager.Users.SingleOrDefault(r => r.Email == authVM.Username);
var role = _userManager.GetRolesAsync(user).Result[0];
var tokenString = new JWTGenerator().GenerateJWT(user, _configuration, role);
return(Ok(new { token = tokenString, username = authVM.Username }));
}
return(Unauthorized());
}
public Login()
{
InitializeComponent();
auth = new AuthVM()
{
Email = "*****@*****.**",
Password = "******"
};
BindingContext = auth;
}
public Login(string username)
{
InitializeComponent();
auth = new AuthVM()
{
Email = username,
Password = ""
};
BindingContext = auth;
}
public async Task <PersonDTO> Login(AuthVM auth)
{
var personRepo = _service.GetService <IPersonRepo>();
var user = await personRepo.Login(auth.Username, auth.Password);
var personDTO = Mapper.Map <PersonDTO>(user);
return(personDTO);
}
public async Task <UserDTO> Login(AuthVM auth)
{
var userRepo = _service.GetService <IUserRepo>();
var user = await userRepo.Login(auth.Username, auth.Password);
var userDTO = Mapper.Map <UserDTO>(user);
return(userDTO);
}
public async Task <ActionResult> AddClaim(AuthVM authVM)
{
string userId = authVM.Id;
string claimValue = authVM.Claims.First();
bool isSucceed = await authService.AddClaim(userId, claimValue);
if (!isSucceed)
{
return(StatusCode(500));
}
return(Ok());
}
public Registration()
{
InitializeComponent();
auth = new AuthVM()
{
Email = "",
Password = "",
ConfirmPassword = "",
ErrorMessage = "Init Error"
};
BindingContext = auth;
}
public LoginPage()
{
InitializeComponent();
UsernameEntry.Text = "user1";
PasswordEntry.Text = "password1";
//UsernameEntry.Text = "admin";
//PasswordEntry.Text = "admin";
BindingContext = viewModel = new AuthVM();
SignUp.GestureRecognizers.Add(new TapGestureRecognizer((view) => OnSignUpButtonClicked()));
}
public Page IsUseregistered(bool isEnabaled)
{
bool isUserRegistered = (isEnabaled == true) ? isEnabaled : AuthVM.IsUseregisteredAsync().Result;
if (isUserRegistered)
{
return(new AppShell());
}
else
{
return(new Login());
}
}
public async Task <IActionResult> Login(string returnURL, AuthVM model)
{
if (ModelState.IsValid)
{
var usr = await _usuarioRepository.SighInAsync(model.Email, model.Senha);
if (usr is null)
{
ModelState.AddModelError("", "Email ou Senha invalidos");
return(View(model));
}
var claims = new List <Claim>
{
new Claim("nomeUsuario", usr.Nome),
new Claim("email", usr.Email),
new Claim("idUsuario", usr.Id.ToString())
};
var identity = new ClaimsIdentity(claims,
CookieAuthenticationDefaults.AuthenticationScheme,
"nomeUsuario",
string.Join(", ", usr.Perfis.Select(x => x.Nome)));
await HttpContext.SignInAsync(
new ClaimsPrincipal(identity),
new AuthenticationProperties()
{
ExpiresUtc = DateTime.UtcNow.AddMinutes(30) // pra nao pegar o utc do brasil
}
);
}
if (string.IsNullOrEmpty(returnURL))
{
return(RedirectToAction("index", "home"));
}
else
{
if (Url.IsLocalUrl(returnURL))
{
return(Redirect(returnURL));
}
else
{
return(RedirectToAction("index", "home"));
}
}
}
private void btnLogin_Click(object sender, EventArgs e)
{
var auth = new AuthVM()
{
Email = txtEmail.Text,
Password = txtPassword.Text
};
var resp = postLogin.PostResponse(auth);
if (resp.IsSuccessStatusCode)
{
var verifikovaniKorisnik = resp.Content.ReadAsAsync <VerifikovanKorisnikVM>().Result;
this.Hide();
var form1 = new Form1(verifikovaniKorisnik);
form1.ShowDialog();
}
}
public JsonResult Authenticate([FromBody] AuthVM authVM)
{
var id = _auth.Authorize(authVM);
if (id == null)
{
return(new JsonResult("")
{
StatusCode = 403,
Value = "Неверный логин или пароль."
});
}
return(new JsonResult("")
{
StatusCode = 200,
Value = JsonConvert.SerializeObject(new { id = id })
});
}
public IHttpActionResult Login([FromBody] AuthVM auth)
{
var korisnik = GetUser(auth.Email, CryptoHelper.GetMd5Hash(auth.Password));
if (korisnik != null)
{
var token = JwtManager.GenerateToken(korisnik);
return(Ok(new VerifikovanKorisnikVM()
{
Id = korisnik.Id,
ImePrezime = korisnik.Ime + " " + korisnik.Prezime,
Token = token,
TipKorisnika = korisnik.TipKorisnika,
isUserRole = (int)korisnik.TipKorisnika != 2 ? 0 : 1
}));
}
return(StatusCode(HttpStatusCode.Unauthorized));
}
public async Task <ActionResult <AuthVM> > SignIn(IdentityUser user)
{
Console.WriteLine(user);
AuthVM authVM = new AuthVM();
authVM.IsAuthenticated = await authService.AuthenticateUser(user.UserName, user.PasswordHash);
if (authVM.IsAuthenticated)
{
authVM.JWT = await authService.CreateJWT(user.UserName);
IdentityUser identityUser = await authService.FindUserByUserName(user.UserName);
authVM.Id = identityUser.Id;
authVM.UserName = identityUser.UserName;
authVM.Email = identityUser.Email;
authVM.Claims = (await authService.GetClaims(identityUser.Id))
.Select((Claim claim) => claim.Value)
.ToList();
}
return(Ok(authVM));
}
private async Task <bool> PostLogin()
{
var loginService = new WebAPIHelper("api/korisnici/login/");
var auth = new AuthVM()
{
Email = entryEmail.Text,
Password = entryPassword.Text
};
var response = await loginService.PostResponse(auth);
if (response.IsSuccessStatusCode)
{
var korisnik = WebAPIHelper.GetResponseContent <VerifikovanKorisnikVM>(response);
ApplicationProperties.UserToken = korisnik.Token;
ApplicationProperties.KorisnikId = korisnik.Id.ToString();
ApplicationProperties.userRole = (int)korisnik.isUserRole;
return(true);
}
return(false);
}
public async Task <IActionResult> Login([FromBody] AuthVM authVM)
{
var result = await _signInManager.PasswordSignInAsync(authVM.Username, authVM.Password, false, false);
if (result.Succeeded)
{
var authService = _service.GetService <IAuth>();
var auth = await authService.Login(authVM);
if (auth == null)
{
return(Unauthorized());
}
var user = _userManager.Users.SingleOrDefault(r => r.Email == authVM.Username);
var tokenString = new JWTGenerator().GenerateJWT(auth, _configuration);
return(Ok(new { token = tokenString, username = authVM.Username }));
}
return(Unauthorized());
}
private void DoLogout()
{
AuthVM.LogOff();
}
private void DoLogin(object obj)
{
AuthVM.Authenticate();
}
private void DoLogout(object obj)
{
AuthVM.LogOff();
}
public int Authorize(AuthVM authVM)
{
var user = _userStorage.Get(authVM.Login, authVM.Password);
return(user.UserId);
}
public AuthPage()
{
InitializeComponent();
BindingContext = model = new AuthVM();
}
public async Task <ActionResult> LoginAccount([FromBody] AuthCM authCM)
{
if (string.IsNullOrEmpty(authCM.LoginType))
{
return(BadRequest());
}
var auth = FirebaseAdmin.Auth.FirebaseAuth.DefaultInstance;
string email;
try
{
var token = await auth.VerifyIdTokenAsync(authCM.IdToken);
email = (string)token.Claims[TokenClaims.EMAIL];
}
catch (Exception e)
{
return(Unauthorized(e.Message));
}
AuthVM response;
try
{
//string email = "*****@*****.**";
Account accountCreated = _accountService.GetByEmail(email);
if (accountCreated == null)
{
Gallery gallery = null;
if (authCM.Avatar != null)
{
gallery = new Gallery()
{
Name = authCM.LoginType + "_GALLERY",
Description = "GALLERY OF " + authCM.LoginType
};
Image img = new Image()
{
Description = "IMAGES OF " + authCM.LoginType,
ImageUrl = authCM.Avatar
};
gallery.Images = new List <Image>();
gallery.Images.Add(img);
}
accountCreated = new Account()
{
DisplayName = authCM.DisplayName,
Email = email,
Role = Constants.Role.ADMIN,
Status = Constants.AccountStatus.ACTIVE,
Gallery = gallery,
IsBeautyArtist = true
};
await _accountService.AddAsync(accountCreated);
await _accountService.Save();
}
else
{
if (!accountCreated.Status.Equals("ACTIVE"))
{
return(BadRequest());
}
}
string role = accountCreated.Role;
if (role != authCM.LoginType)
{
return(BadRequest());
}
var uid = accountCreated.Id;
string accessToken = await _jwtTokenProvider.GenerateToken(accountCreated);
response = new AuthVM()
{
Uid = accountCreated.Id,
DisplayName = accountCreated.DisplayName,
Email = accountCreated.Email,
Phone = accountCreated.Phone,
Role = accountCreated.Role,
AccessToken = accessToken,
ExpiresIn = Constants.EXPIRES_IN_DAY,
Gallery = _mapper.Map <GalleryVM>(accountCreated.Gallery)
};
if (accountCreated.Role.Equals("ADMIN"))
{
response.Addresses = accountCreated.Addresses;
}
}
catch (Exception e)
{
Response.StatusCode = StatusCodes.Status500InternalServerError;
return(new JsonResult(e.Message));
}
return(Ok(response));
}
