public WorkItemNotificationModel(WorkItem workItem, ApplicationUser user)
{
Id = workItem.Id;
Name = workItem.Name;
User = user.ToString();
User = user.Id;
}
protected String GetUserFullName()
{
ApplicationUser Userid = GetLoggedInUser();
String Variable = Userid.ToString();
return(Variable);
}
public async Task <IHttpActionResult> Register(RegisterBindingModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var user = new ApplicationUser()
{
UserName = model.UserName, Email = model.Email
};
log.Info("user:"******"Failed.", ex);
log.Error(ex.Message);
log.Error(ex.StackTrace);
throw ex;
}
if (!result.Succeeded)
{
return(GetErrorResult(result));
}
return(Ok());
}
public WorkItemNotificationViewModel(WorkItem workItem, ApplicationUser user)
{
Id = workItem.Id;
Name = workItem.Name;
User = user.ToString();
UserId = user.Id;
Type = new EnumViewModel <WorkItemType>(workItem.Type);
}
public async Task <IActionResult> OnPostAsync()
{
if (!ModelState.IsValid)
{
return(Page());
}
var user = await _userManager.GetUserAsync(User);
if (user == null)
{
return(NotFound($"Usuario no encontrado ID: '{_userManager.GetUserId(User)}'."));
}
var changePasswordResult = await _userManager.ChangePasswordAsync(user, Input.OldPassword, Input.NewPassword);
if (!changePasswordResult.Succeeded)
{
foreach (var error in changePasswordResult.Errors)
{
ModelState.AddModelError(string.Empty, error.Description);
}
return(Page());
}
// var user = await _signInManager.UserManager.FindByNameAsync(Input.Email);
ApplicationUser currentUser = DB.ApplicationUser
.FirstOrDefault(u => u.Id == user.Id);
Console.WriteLine("======================================");
Console.WriteLine(currentUser.ToString());
currentUser.LastChangedPassword = DateTime.Now;
Console.WriteLine(currentUser.LastChangedPassword);
Console.WriteLine("======================================");
await _signInManager.RefreshSignInAsync(user);
DB.Update(currentUser);
await DB.SaveChangesAsync();
_logger.LogInformation("El usuario cambió su contraseña exitosamente.");
StatusMessage = "Tu contraseña ha sido cambiada.";
if (Input.ReturnUrl != null)
{
return(LocalRedirect(Input.ReturnUrl));
}
else
{
return(LocalRedirect("/"));
}
}
public void LogEvent(string eventTypeCode, ApplicationUser appUser)
{
var eventLog = new EventLog
{
EventTypeCode = eventTypeCode,
UserCreatedID = appUser.Id,
UserCreatedName = appUser.UserName,
DataValues = "User=" + appUser.ToString(),
DateTimeCreated = DateTime.Now
};
_eventLogRepository.Add(eventLog);
}
private async void Login(OAuthGrantResourceOwnerCredentialsContext context)
{
var userManager = context.OwinContext.GetUserManager <ApplicationUserManager>();
ApplicationUser userid = await userManager.FindAsync(context.UserName, context.Password);
if (userid != null)
{
////here you can start with your claim stuff
ClaimsIdentity identity = new ClaimsIdentity(new List <Claim> {
new Claim("userId", userid.ToString())
}, OAuthDefaults.AuthenticationType);
identity.AddClaim(new Claim(ClaimTypes.Name, context.UserName));
context.Validated(identity);
return;
}
}
public void LogEvent(string eventTypeCode, ApplicationUser appUser, ProgramEnrollment enrollment)
{
Console.WriteLine("");
Console.WriteLine("------------------------------------------------------------------------------------------");
Console.WriteLine("[EventLogService][LogEvent][ProgramEnrollment] - (ApplicationUser.ToString()):\n"
+ appUser);
Console.WriteLine("");
Console.WriteLine("[EventLogService][LogEvent][ProgramEnrollment] - (ApplicationUser.ToEventLog()):\n"
+ appUser.ToEventLog());
Console.WriteLine("------------------------------------------------------------------------------------------");
Console.WriteLine("");
Console.WriteLine("");
Console.WriteLine("------------------------------------------------------------------------------------------");
Console.WriteLine("[EventLogService][LogEvent][ProgramEnrollment] - (ProgramEnrollment.ToString()):\n"
+ enrollment);
Console.WriteLine("");
Console.WriteLine("[EventLogService][LogEvent][ProgramEnrollment] - (ProgramEnrollment.ToEventLog()):\n"
+ enrollment.ToEventLog());
Console.WriteLine("------------------------------------------------------------------------------------------");
Console.WriteLine("");
var sb = new StringBuilder();
sb.Append("User="******"; ");
//sb.Append(enrollment.ToString());
var eventLog = new EventLog
{
EventTypeCode = eventTypeCode,
UserCreatedID = appUser.Id,
UserCreatedName = appUser.UserName,
DataValues = sb.ToString(),
DateTimeCreated = DateTime.Now
};
_eventLogRepository.Add(eventLog);
}
private async Task SignInAsync(ApplicationUser user, bool isPersistent)
{
Logger.Debug("SignInAsync " + user.Email + " " + user.FirstName + " " + user.ToString());
AuthenticationManager.SignOut(DefaultAuthenticationTypes.ExternalCookie);
var identity = await UserManager.CreateIdentityAsync(user, DefaultAuthenticationTypes.ApplicationCookie);
await SetExternalProperties(identity);
AuthenticationManager.SignIn(new AuthenticationProperties() { IsPersistent = isPersistent }, identity);
await SaveAccessToken(user, identity);
}
public async Task <(User, string message)> Authenticate(LoginDTO _login)
{
// var user = _users.SingleOrDefault(x => x.Username == username && x.Password == password);
//var ApplicationUser = new ApplicationUser { UserName = username };
var user = new ApplicationUser();
//if (IsValidEmailAddress(_login.Username))
//{
user = await _userManager.FindByEmailAsync(_login.UserName);
//}
//else
//{
// user = await _userManager.FindByNameAsync(_login.Username);
// //return null;
//}
// return null if user not found
if (user == null)
{
return(null, "This user does not exists!");
}
else if (user != null && await _userManager.CheckPasswordAsync(user, _login.Password))
{
var roleId = _context.UserRoles.Where(r => r.UserId == user.Id).FirstOrDefault();
var roleName = _context.Roles.Where(r => r.Id == roleId.RoleId).FirstOrDefault().Name;
// authentication successful so generate jwt token
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.ToString()),
new Claim(ClaimTypes.Role, roleName)
}),
Expires = roleName == "Student" ? DateTime.UtcNow.AddDays(365) : DateTime.UtcNow.AddMinutes(60),
SigningCredentials = new SigningCredentials(new SymmetricSecurityKey(key), SecurityAlgorithms.HmacSha256Signature)
};
var securityToken = tokenHandler.CreateToken(tokenDescriptor);
var token = tokenHandler.WriteToken(securityToken);
var userResult = new User();
userResult = new User()
{
Id = user.Id,
Username = user.UserName,
Role = roleName,
Token = token,
IdRole = roleId.RoleId,
Email = user.Email,
//isActive = user.isActive
};
return(userResult, "");
}
return(null, "Credentials are not correct!");
}
public async Task <ActionResult> UpdateUserAsync(string id, [FromBody] ApplicationUser request)
{
var user = await _userManager.FindByIdAsync(id);
if (user == null)
{
return(NotFound());
}
var roles = await _userManager.GetRolesAsync(user);
if (!string.IsNullOrWhiteSpace(request.Email))
{
user.Email = request.Email;
user.UserName = request.Email;
}
if (!string.IsNullOrWhiteSpace(request.Email))
{
user.Email = request.Email;
}
if (!string.IsNullOrWhiteSpace(request.FirstName))
{
user.FirstName = request.FirstName;
}
if (!string.IsNullOrWhiteSpace(request.LastName))
{
user.LastName = request.LastName;
}
if (request.Gender != "")
{
user.Gender = request.Gender;
}
if (!string.IsNullOrWhiteSpace(request.CompanyName))
{
user.CompanyName = request.CompanyName;
}
//
var updateResult = await _userManager.UpdateAsync(user);
if (updateResult.Succeeded)
{
user.UserRole = roles.Contains("AdminUser") ? "AdminUser" : "BasicUser";
return(Ok(user));
}
var errors = updateResult.Errors.Select(x => x.Description).ToList();
return(BadRequest(new ErrorResult
{
Message = "Error updating user with email: " + user.Email + " using request: " + request.ToString(),
Errors = errors
}));
}
public async Task <ActionResult> UpdateCurrentUserAsync([FromBody] ApplicationUser request)
{
string userEmail = ((ClaimsIdentity)User.Identity).Claims.Where(c => c.Type == ClaimTypes.Email).FirstOrDefault().Value;
var user = await _userManager.FindByEmailAsync(userEmail);
if (user == null)
{
return(NotFound());
}
var roles = await _userManager.GetRolesAsync(user);
if (!string.IsNullOrWhiteSpace(request.Email))
{
//TODO: Can a user A change email to the same email as another user? ...
//var result = await _userManager.ChangeEmailAsync(user, request.Email);
user.Email = request.Email;
user.UserName = request.Email;
}
if (!string.IsNullOrWhiteSpace(request.FirstName))
{
user.FirstName = request.FirstName;
}
if (!string.IsNullOrWhiteSpace(request.LastName))
{
user.LastName = request.LastName;
}
if (request.Gender != "")
{
user.Gender = request.Gender;
}
if (!string.IsNullOrWhiteSpace(request.CompanyName))
{
user.CompanyName = request.CompanyName;
}
//
var updateResult = await _userManager.UpdateAsync(user);
if (updateResult.Succeeded)
{
user.UserRole = roles.Contains("AdminUser") ? "AdminUser" : "BasicUser";
return(Ok(user));
}
var errors = updateResult.Errors.Select(x => x.Description).ToList();
return(BadRequest(new ErrorResult
{
Message = "Error updating user with email: " + user.Email + " using request: " + request.ToString(),
Errors = errors
}));
}
