public AuthHandler(
NotificationContext notification,
IUserManager userManager,
AuthValidator validator) : base(notification, userManager)
{
_validator = validator;
}
public ActionResult Create([Bind(Include = "Email,Password")] Login login)
{
try
{
if (ModelState.IsValid)
{
AuthValidator authValidator = new AuthValidator();
tbl_empoyee tbl_Empoyee = authValidator.IsvalidUser(login);
Session["Email"] = tbl_Empoyee.email;
Session["Role"] = tbl_Empoyee.tbl_role.role_name;
Session["Name"] = tbl_Empoyee.emp_name;
return(RedirectToAction("Index", "Home"));
}
else
{
return(View(login));
}
}
catch (Exception exception)
{
ViewBag.errormeaasge = exception.Message;
return(View());
}
}
public async Task <object> Register([FromBody] RegisterDto model)
{
if (!ModelState.IsValid)
{
var errrors = AuthValidator.GetErrorsByModel(ModelState);
return(BadRequest(errrors));
}
var user = new IdentityUser
{
UserName = model.Email,
Email = model.Email
};
var result = await _userManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
await _signInManager.SignInAsync(user, false);
return(Ok(await GenerateJwtToken(model.Email, user)));
}
else
{
return(BadRequest(result.Errors));
}
}
public async Task <IActionResult> AddTask([FromBody] TaskDto task)
{
if (!ModelState.IsValid)
{
var errrors = AuthValidator.GetErrorsByModel(ModelState);
return(BadRequest(errrors));
}
try
{
string userId = User.Claims.FirstOrDefault(c => c.Type == ClaimTypes.NameIdentifier).Value;
DAL.Entities.Task newtask = new DAL.Entities.Task()
{
ApplicationUserId = userId, Category = _context.Categories.FirstOrDefault(x => x.CategoryName == task.Category), date = task.date, Description = task.Description, Name = task.Name, IsComplited = task.IsComplited
};
_context.Tasks.Add(newtask);
await _context.SaveChangesAsync();
return(Ok());
}
catch (Exception ex)
{
return(BadRequest(ex));
}
}
public async Task <Authentication.OutModel> Authentication([FromBody] Authentication.InModel inModel)
{
AuthValidator validationRules = new AuthValidator();
await validationRules.ValidateAndThrowAsync(inModel);
return(await _iAccessControlService.Authentication(inModel));
}
public ActionResult Index()
{
if (AuthValidator.IsAdministrator(Session["Email"].ToString(), Session["Role"].ToString()))
{
return(RedirectToAction("AdminIndex", "Home"));
}
else
{
return(View());
}
}
public void Should_ReturnTrue_When_UseValalidAsync(string authModel)
{
//Arrange
var validator = new AuthValidator();
AuthDTO dto = GetTestDTOModel(authModel);
//Act
var validationResult = validator.Validate(dto);
//Assert
Assert.True(validationResult.IsValid);
}
// GET: tbl_empoyee
public ActionResult Index()
{
if (AuthValidator.IsAdministrator(Session["Email"].ToString(), Session["Role"].ToString()))
{
var tbl_empoyee = db.tbl_empoyee.Include(t => t.tbl_role);
return(View(tbl_empoyee.ToList()));
}
else
{
return(RedirectToAction("index", "Login"));
}
}
public static async Task <HttpResponseMessage> Run(
[HttpTrigger(AuthorizationLevel.Anonymous, "get", "post", Route = null)] HttpRequestMessage req, TraceWriter log)
{
log.Info("C# HTTP trigger function processed a request.");
// Authentication boilerplate code start
ClaimsPrincipal principal;
if ((principal = await AuthValidator.ValidateTokenAsync(req.Headers.Authorization)) == null)
{
return(req.CreateResponse(HttpStatusCode.Unauthorized));
}
// Authentication boilerplate code end
// parse query parameter
string queryStr = req.RequestUri.Query;
if (!String.IsNullOrEmpty(queryStr))
{
}
string name = req.RequestUri.Query;
if (!string.IsNullOrEmpty(name) && name.StartsWith("?"))
{
name = name.Substring(1);
}
// Get request body
dynamic data = await req.Content.ReadAsAsync <object>();
// Set name to query string or body data
name = name ?? data?.name;
return(name == null
? new HttpResponseMessage(HttpStatusCode.BadRequest)
{
Content = new StringContent(@"Please pass a name on the query string or in the request body")
}
: new HttpResponseMessage(HttpStatusCode.OK)
{
Content = new StringContent($"Hello {name}")
});
}
public async Task <object> Login([FromBody] LoginDto model)
{
if (!ModelState.IsValid)
{
var errrors = AuthValidator.GetErrorsByModel(ModelState);
return(BadRequest(errrors));
}
var result = await _signInManager.PasswordSignInAsync(model.Email, model.Password, false, false);
if (result.Succeeded)
{
var appUser = new IdentityUser
{
Email = model.Email
};
return(await GenerateJwtToken(model.Email, appUser));
}
else
{
return(BadRequest(new { invalid = "You entered an invalid credentials!" }));
}
}
public async Task <Authentication.Models.OutModel> Authentication(Authentication.Models.InModel inModel,
CancellationToken cancellationToken = default)
{
AuthValidator authValidator = new AuthValidator();
await authValidator.ValidateAndThrowAsync(inModel);
var user = await _dbContext.Users.SingleOrDefaultAsync(x => x.Email == inModel.Email, cancellationToken);
if (user == null)
{
throw new InvalidOperationException("User with email not exist.");
}
if (!Cryptor.VerifyPasswordHash(inModel.PasswordHash, user.PasswordHash))
{
throw new InvalidOperationException("Email or password is incorrect.");
}
var tokenHandler = new JwtSecurityTokenHandler();
var key = Encoding.ASCII.GetBytes(_appSettings.Secret);
var tokenDescriptor = new SecurityTokenDescriptor
{
Subject = new ClaimsIdentity(new Claim[]
{
new Claim(ClaimTypes.Name, user.Id.ToString())
}),
Expires = DateTime.UtcNow.AddDays(7),
SigningCredentials = new SigningCredentials(new SymmetricSecurityKey(key),
SecurityAlgorithms.HmacSha256Signature)
};
var token = tokenHandler.CreateToken(tokenDescriptor);
user.Token = tokenHandler.WriteToken(token);
return(new Authentication.Models.OutModel {
IdUser = user.Id,
UserName = user.Username, Token = user.Token
});
}
