// GET: Home
public async Task<ActionResult> Index()
{
var context = new ApplicationDbContext(); // DefaultConnection
var store = new UserStore<CustomUser>(context);
var manager = new UserManager<CustomUser>(store);
var email = "*****@*****.**";
var password = "******";
var user = await manager.FindByEmailAsync(email);
if (user == null)
{
user = new CustomUser
{
UserName = email,
Email = email,
FirstName = "Super",
LastName = "Admin"
};
await manager.CreateAsync(user, password);
}
else
{
user.FirstName = "Super";
user.LastName = "Admin";
await manager.UpdateAsync(user);
}
return Content("Hello, Index");
}
public async Task<IdentityResult> UpdateUser(IdentityUser user)
{
IdentityResult user1 = null;
try
{
_ctx = new AuthContext();
_userManager = new UserManager<IdentityUser>(new UserStore<IdentityUser>(_ctx));
user1 = await _userManager.UpdateAsync(user);
}
catch (Exception ex) { }
return user1;
}
public async Task<WikiDownUser> Save(IPrincipal principal, UserManager<WikiDownUser> userManager)
{
var user = await userManager.FindByNameAsync(this.UserName);
var roles = this.GetRoles(principal, user);
if (user != null)
{
if (user.UserName == principal.Identity.Name)
{
var userAccessLevel = ArticleAccessHelper.GetAccessLevel(user.Roles);
if (userAccessLevel < ArticleAccessLevel.Admin)
{
throw new HttpResponseException(HttpStatusCode.BadRequest);
}
}
user.SetRoles(roles);
user.SetDisplayName(this.DisplayName);
user.SetEmail(this.Email);
if (!string.IsNullOrWhiteSpace(this.Password))
{
await userManager.RemovePasswordAsync(user.Id);
await userManager.AddPasswordAsync(user.Id, this.Password);
}
await userManager.UpdateAsync(user);
WikiDownUserCacheHelper.Clear(user.UserName);
}
else
{
user = new WikiDownUser(this.UserName) { Roles = roles };
user.SetDisplayName(this.DisplayName);
user.SetEmail(this.Email);
await userManager.CreateAsync(user, this.Password);
}
return user;
}
private async Task <IdentityResult> UpdateUserAsync(AppUser user)
{
IdentityResult identityResult = await userManager.UpdateAsync(user);
return(identityResult);
}
public async Task <ActionResult> Update(UpdateAccountDto updateAccountDto)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState.Values.SelectMany(x => x.Errors)));
}
var user = await GetAuthenticatedUserAccount();
if (user == null)
{
return(NotFound(new { Message = "User account not found" }));
}
if (!string.IsNullOrEmpty(updateAccountDto.Email) &&
user.Email != updateAccountDto.Email &&
await _userManager.Users.FirstOrDefaultAsync(u => u.Email == updateAccountDto.Email) == null)
{
user.EmailConfirmed = false;
user.Email = updateAccountDto.Email;
var mailToken = await _userManager.GenerateEmailConfirmationTokenAsync(user);
var confirmationUrl = Url.Link("ConfirmEmail", new { token = mailToken, email = user.Email });
await _mailService.SendMailAsync(
user.Email,
"Agree - Confirmation",
$"<html><body>Hello, {user.DisplayName}#{user.Tag.ToString().PadLeft(4, '0')}. Please click <a href=\"{confirmationUrl}\">HERE</a> to confirm your new email.</body></html>");
}
if (!string.IsNullOrEmpty(updateAccountDto.UserName) &&
user.DisplayName != updateAccountDto.UserName)
{
var userWithSameTagAndName = await _userManager.Users.FirstOrDefaultAsync(
u => u.DisplayName == updateAccountDto.UserName &&
u.Tag == user.Tag);
if (userWithSameTagAndName == null)
{
user.DisplayName = updateAccountDto.UserName;
}
}
if (user.Tag != updateAccountDto.Tag)
{
var userWithSameTagAndName = await _userManager.Users.FirstOrDefaultAsync(
u => u.DisplayName == user.DisplayName &&
u.Tag == updateAccountDto.Tag);
if (userWithSameTagAndName == null)
{
user.Tag = updateAccountDto.Tag;
if (!string.IsNullOrEmpty(updateAccountDto.UserName) &&
user.DisplayName != updateAccountDto.UserName)
{
userWithSameTagAndName = await _userManager.Users.FirstOrDefaultAsync(
u => u.DisplayName == updateAccountDto.UserName &&
u.Tag == user.Tag);
if (userWithSameTagAndName == null)
{
user.DisplayName = updateAccountDto.UserName;
}
}
}
}
var result = await _userManager.UpdateAsync(user);
if (!result.Succeeded)
{
return(BadRequest(new { result.Errors }));
}
var userViewModel = _mapper.Map <ApplicationUserViewModel>(user);
Response.Cookies.Append("agreeallow_accesstoken", await _tokenService.GenerateToken(user.Email), new CookieOptions
{
HttpOnly = true,
SameSite = SameSiteMode.Strict
});
return(Ok(new UserResponse(userViewModel)));
}
public async Task <IActionResult> OnPostAsync()
{
if (!ModelState.IsValid)
{
return(Page());
}
var user = await _userManager.GetUserAsync(User);
if (user == null)
{
return(NotFound($"Unable to load user with ID '{_userManager.GetUserId(User)}'."));
}
user.Qualification = Input.QualificationType;
var qualificationName = user.QualificationName;
if (Input.QualificationName != qualificationName)
{
user.QualificationName = Input.QualificationName;
// Error checking will need to be added here to ensure in the event something fails it updates.
}
var qulificationCompletionYear = user.QulificationCompletionYear;
if (Input.QualificationCompletionYear != qulificationCompletionYear)
{
user.QulificationCompletionYear = Input.QualificationCompletionYear;
// Error checking will need to be added here to ensure in the event something fails it updates.
}
var currentStudyingQualification = user.CurrentStudyingQualification;
if (Input.CurrentStudyingQualification != user.CurrentStudyingQualification)
{
user.CurrentStudyingQualification = Input.CurrentStudyingQualification;
// Error checking will need to be added here to ensure in the event something fails it updates.
}
var currentQualificationType = user.CurrentQualificationType;
if (Input.CurrentQualificationType != user.CurrentQualificationType)
{
user.CurrentQualificationType = Input.CurrentQualificationType;
// Error checking will need to be added here to ensure in the event something fails it updates.
}
var citizenshipStudyStatus = user.CitizenshipStudyStatus;
if (Input.isStudyasInternationalStudent != user.CitizenshipStudyStatus)
{
user.CitizenshipStudyStatus = Input.isStudyasInternationalStudent;
// Error checking will need to be added here to ensure in the event something fails it updates.
}
var studyingAtSwinburne = user.StudyingAtSwinburne;
if (Input.StudyingAtSwinburne != user.StudyingAtSwinburne)
{
user.StudyingAtSwinburne = Input.StudyingAtSwinburne;
// Error checking will need to be added here to ensure in the event something fails it updates.
}
var areYouStudying = user.AreYouStudying;
if (Input.AreYouStudying != user.AreYouStudying)
{
user.AreYouStudying = Input.AreYouStudying;
// Error checking will need to be added here to ensure in the event something fails it updates.
}
if (Input.YouTubeURL != user.YoutubeUrl)
{
user.YoutubeUrl = Input.YouTubeURL;
}
await _userManager.UpdateAsync(user);
await _signInManager.RefreshSignInAsync(user);
var result = await FullRegistrationAsync();
user.UserFullyRegistered = result;
await _userManager.UpdateAsync(user);
StatusMessage = "Your Qualification Details have been updated";
return(RedirectToPage());
}
public async Task <ActionResult> Register(RegisterViewModel model)
{
model.ListaEstados = ListarEstados();
model.ListaTipoPessoas = ListarTipoPessoas();
model.ListaSexo = ListarSexo();
model.Roles = this.RoleManager.Roles.Where(i => i.Name != Config.Roles.Administrador && i.Name != Config.Roles.Gerente).Select(r => new SelectListItem {
Value = r.Name, Text = r.Name
}).ToList();
if (ModelState.IsValid)
{
var user = new ApplicationUser
{
UserName = model.Email,
Email = model.Email,
Nome = model.Nome,
TipoPessoa = model.TipoPessoa,
CpfCnpj = model.CpfCnpj,
Rg = model.Rg,
DataNascimento = model.DataNascimento,
EstadoCivil = model.EstadoCivil,
Nascionalidade = model.Nascionalidade,
Profissao = model.Profissao,
Sexo = model.Sexo,
Cep = model.Cep,
Logradouro = model.Logradouro,
Numero = model.Numero,
Complemento = model.Complemento,
Bairro = model.Bairro,
Cidade = model.Cidade,
Uf = model.Uf,
TelefoneResidencial = model.TelefoneResidencial,
TelefoneCelular = model.TelefoneCelular,
TelefoneComercial = model.TelefoneComercial,
};
var result = await UserManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
await this.UserManager.AddToRoleAsync(user.Id, model.Role);
await UserManager.UpdateAsync(user);
//await SignInManager.SignInAsync(user, isPersistent:false, rememberBrowser:false);
// For more information on how to enable account confirmation and password reset please visit http://go.microsoft.com/fwlink/?LinkID=320771
// Send an email with this link
string code = await UserManager.GenerateEmailConfirmationTokenAsync(user.Id);
var callbackUrl = Url.Action("ConfirmEmail", "Account", new { userId = user.Id, code = code }, protocol: Request.Url.Scheme);
await UserManager.SendEmailAsync(user.Id, "Valide seu Cadastro", "Por favor, valide seu cadastro clicando " + String.Format("<a href=\"{0}\">{1}</a>", callbackUrl, "aqui"));
ViewBag.Message = "Verifique o seu email e confirme a sua conta, você tem que confirmar a sua conta antes de fazer o login ";
return(View("Info"));
//return RedirectToAction("Index", "Home");
}
AddErrors(result);
}
// If we got this far, something failed, redisplay form
return(View(model));
}
public async Task <IActionResult> SubmitTokenInput(TokenInputViewModel model)
{
if (!ModelState.IsValid ||
String.IsNullOrWhiteSpace(model.Email) ||
String.IsNullOrWhiteSpace(model.Purpose) ||
String.IsNullOrWhiteSpace(model.Token))
{
return(View(model));
}
var email = _userManager.NormalizeKey(model.Email);
model.Token = model.Token.Replace(" ", "");
var userWithConfirmedEmail = await _userManager.FindByLoginAsync("Email", email);
var userCurrentlySignedIn = await _userManager.GetUserAsync(User);
var userEmpty = new ApplicationUser()
{
Id = email,
Email = email,
SecurityStamp = TemporarySecurityStamp
};
var isTokenValid = false;
if (model.Purpose == "RegisterOrLogin") // Trying to register or login
{
await _signInManager.SignOutAsync();
isTokenValid = await _userManager.VerifyUserTokenAsync(
userWithConfirmedEmail // Case: logging-in
?? userEmpty, // Case: registering,
"Email", model.Purpose, model.Token);
}
else // Trying to add email
{
if (userCurrentlySignedIn == null) // If the user is not signed in, prompt them to, with the return url leading back here
{
return(RedirectToAction(nameof(Login), new
{
returnUrl = Request.Path + Request.QueryString
}));
}
isTokenValid = await _userManager.VerifyUserTokenAsync(
userCurrentlySignedIn,
"Email", model.Purpose, model.Token);
}
if (!isTokenValid)
{
_notice.AddErrors(ModelState, "Error validating code, it might have expired. Please try again!");
return(View(model));
}
// Invalidates all tokens for user when trying to login or add login
// Note: this also invalidates any attempts to add more logins than allowed
if ((userCurrentlySignedIn ?? userWithConfirmedEmail) != null)
{
var updateSecStampResult = await _userManager.UpdateSecurityStampAsync(userCurrentlySignedIn ?? userWithConfirmedEmail);
if (!updateSecStampResult.Succeeded)
{
_notice.AddErrors(ModelState);
return(View(model));
}
}
// Valid {token + email (user) + purpose} supplied
if (model.Purpose == "RegisterOrLogin") // Trying to register or login
{
if (userWithConfirmedEmail == null) // Success trying to register
{
var token = await _userManager.GenerateUserTokenAsync(userEmpty, "Default", "Register");
return(View(nameof(Register), new RegisterViewModel
{
RememberMe = model.RememberMe,
Email = email,
UserName = GenerateUserName(email),
Token = token,
ReturnUrl = model.ReturnUrl
}));
}
else // Success trying to login
{
await _events.AddEvent(AuthEventType.Login, JsonConvert.SerializeObject(new
{
LoginProvider = "Email",
ProviderKey = model.Email
}), userWithConfirmedEmail);
await _signInManager.SignInAsync(userWithConfirmedEmail, isPersistent : model.RememberMe);
}
}
else // Trying to add email
{
var userWithConfirmedEmailToAdd = await _userManager.FindByLoginAsync("Email", email);
if (userWithConfirmedEmailToAdd == null) // Email to be added never seen before, add email to userCurrentlySignedIn
{
var addLoginResult = await _userManager.AddLoginAsync(userCurrentlySignedIn,
new UserLoginInfo("Email", email, "Email"));
if (!addLoginResult.Succeeded)
{
_notice.AddErrors(ModelState, addLoginResult);
return(View(model));
}
userCurrentlySignedIn.Email = email;
userCurrentlySignedIn.EmailConfirmed = true;
var updateUserResult = await _userManager.UpdateAsync(userCurrentlySignedIn);
if (!updateUserResult.Succeeded)
{
_notice.AddErrors(ModelState, updateUserResult);
return(View(model));
}
await _events.AddEvent(AuthEventType.AddLogin, JsonConvert.SerializeObject(new
{
LoginProvider = "Email",
ProviderKey = model.Email
}), userCurrentlySignedIn);
}
else // Email to be added is in use
{
// Note: this area is unlikely to be reached since security stamp is changed once a login is added
if (userWithConfirmedEmailToAdd.Id == userCurrentlySignedIn.Id) // Email is already in user's account
{
_notice.AddErrors(ModelState, "This email is already in your account.");
return(View(model));
}
else // Email associated with another account (same user since both verified!)
{
_notice.AddErrors(ModelState, "This email is in another user's account. Try logging in using that email instead.");
return(View(model));
}
}
}
// Success
return(RedirectToLocal(model.ReturnUrl));
}
public async Task<ActionResult> updateGoalFitBit(string updateGoal)
{
var userStore = new UserStore<ApplicationUser>(context);
var userManager = new UserManager<ApplicationUser>(userStore);
var currentUser = userManager.FindById(User.Identity.GetUserId());
var fitBitUpdateGoal = Convert.ToInt32(updateGoal);
currentUser.FitBitGoal = fitBitUpdateGoal;
try
{
await userManager.UpdateAsync(currentUser);
var saveUser = userStore.Context;
await saveUser.SaveChangesAsync();
TempData["ValidationMessage"] = "Goal Updated To: " + " " + fitBitUpdateGoal;
}
catch
{
TempData["ValidationMessage"] = "Error: Goal Not Updated!";
}
return RedirectToAction("Index");
}
void DisableLockout(UserManager<IdentityUser> manager, IdentityUser identityUser)
{
if (identityUser != null)
{
identityUser.LockoutEnabled = true;
identityUser.LockoutEndDateUtc = null;
manager.UpdateAsync(identityUser);
}
}
public async Task <IdentityResult> UpdateUserAsync(UserDto userDto) => await _userManager.UpdateAsync(userDto);
public Task <IActionResult> UpdateProfile(ChangeProfileModel model)
{
return(MakeChangeAsync(user => userManager.UpdateAsync(user, model.Email, model.DisplayName),
"Account updated successfully."));
}
public async Task <IdentityResult> UpdateUserAsync(AppUser entity)
{
return(await _userManager.UpdateAsync(entity));
}
public async Task<ActionResult> AddPhoneNumber(AddPhoneNumberViewModel model)
{
if (!ModelState.IsValid)
{
return View(model);
}
ApplicationDbContext db = new ApplicationDbContext();
var userStore = new UserStore<ApplicationUser>(db);
var userManager = new UserManager<ApplicationUser>(userStore);
var user = await userManager.FindByIdAsync(User.Identity.GetUserId());
if (user != null)
{
user.PhoneNumber = model.Number;
}
var result = await userManager.UpdateAsync(user);
var ctx = userStore.Context;
var result1 = await ctx.SaveChangesAsync();
// However, it always succeeds inspite of not updating the database
if (!result.Succeeded)
{
AddErrors(result);
}
return RedirectToAction("Index", "Manage");
}
public async Task<ActionResult> Create()
{
FitBit fitbit = new FitBit();
var userStore = new UserStore<ApplicationUser>(context);
var userManager = new UserManager<ApplicationUser>(userStore);
try
{
var currentUser = userManager.FindById(User.Identity.GetUserId());
var progress = Convert.ToDouble(currentUser.FitBitProgress);
var goal = Convert.ToDouble(currentUser.FitBitGoal);
var dateStart = Convert.ToDateTime(currentUser.dateStartFitBit.ToString());
var dateEnd = Convert.ToDateTime(currentUser.dateEndFitBit.ToString());
var percentEarned = (progress / goal) * 100;
int percentEarnedShort = Convert.ToInt32(percentEarned);
dateStart.ToShortDateString();
dateEnd.ToShortDateString();
fitbit.User = currentUser.UserName;
fitbit.Progress = progress.ToString();
fitbit.Goal = goal.ToString();
fitbit.dateStart = dateStart;
fitbit.dateEnd = dateEnd;
fitbit.percentageEarned = percentEarnedShort.ToString();
db.FitBits.Add(fitbit);
db.SaveChanges();
TempData["ValidationMessage"] = "Stats Submitted for " + " " + dateStart + " - " + dateEnd;
var fitBitProgressNew = 0;
currentUser.FitBitProgress = fitBitProgressNew;
try
{
await userManager.UpdateAsync(currentUser);
var saveUser = userStore.Context;
await saveUser.SaveChangesAsync();
}
catch
{
TempData["ValidationMessage"] = "Error: Stats Not Submitted!";
return RedirectToAction("Index", "Fitbit");
}
return RedirectToAction("Manage", "Fitbit");
}
catch
{
TempData["ValidationMessage"] = "Error: Stats Not Submitted!";
return RedirectToAction("Index", "Fitbit");
}
}
public async Task<ActionResult> updateDateFitBit(DateTime dateStart)
{
var userStore = new UserStore<ApplicationUser>(context);
var userManager = new UserManager<ApplicationUser>(userStore);
var currentUser = userManager.FindById(User.Identity.GetUserId());
var dateStartUpdate = dateStart.Date;
//dateEnd is automatically 7 days after date start
var dateEndUpdate = dateStartUpdate.Date.AddDays(7);
currentUser.dateStartFitBit = dateStartUpdate.ToShortDateString();
currentUser.dateEndFitBit = dateEndUpdate.ToShortDateString();
try
{
await userManager.UpdateAsync(currentUser);
var saveUser = userStore.Context;
await saveUser.SaveChangesAsync();
TempData["ValidationMessage"] = "Date Start Set To: " + " " + dateStartUpdate.ToShortDateString();
}
catch
{
TempData["ValidationMessage"] = "Error: Date Start Not Set!";
}
return RedirectToAction("Index");
}
/// <summary>
/// Updates the user's information
/// </summary>
/// <returns></returns>
public async Task <IActionResult> OnPostAsync()
{
if (!ModelState.IsValid)
{
return(Page());
}
CheckUserRolesExist();
// Get signed in user
var user = await _userManager.GetUserAsync(User);
// Remove all associated claims from current user's identity
await _userManager.RemoveClaimsAsync(user, User.Claims);
// Add newly updated claims and sign user back in
if (ModelState.IsValid)
{
// update user's info
user.UserName = UserProfile.Email;
user.FirstName = UserProfile.FirstName;
user.LastName = UserProfile.LastName;
user.Email = UserProfile.Email;
user.Address = UserProfile.Address;
user.Birthday = UserProfile.Birthday;
user.LovesCats = UserProfile.LovesCats;
// Reset password of user
string resetToken = await _userManager.GeneratePasswordResetTokenAsync(user);
await _userManager.ResetPasswordAsync(user, resetToken, UserProfile.Password);
var updatedResult = await _userManager.UpdateAsync(user);
if (updatedResult.Succeeded)
{// Custom Claim type for full name
Claim fullNameClaim = new Claim("FullName", $"{user.FirstName} {user.LastName}");
// Custom claim type for loves cats
Claim lovesCatsClaim = new Claim("LovesCats", user.LovesCats.ToString().ToLower());
// claim type for birthday
Claim birthdayClaim = new Claim(
ClaimTypes.DateOfBirth,
new DateTime(user.Birthday.Year, user.Birthday.Month, user.Birthday.Day).ToString("u"), ClaimValueTypes.DateTime);
// claim type for email
Claim emailClaim = new Claim(ClaimTypes.Email, user.Email, ClaimValueTypes.Email);
// claim for type address
Claim addressClaim = new Claim(ClaimTypes.StreetAddress, user.Address);
List <Claim> myclaims = new List <Claim>()
{
fullNameClaim,
birthdayClaim,
emailClaim,
addressClaim,
lovesCatsClaim
};
// adds the claims
await _userManager.AddClaimsAsync(user, myclaims);
// make admins if emails are these
if (UserProfile.Email.ToLower() == "*****@*****.**" || UserProfile.Email.ToLower() == "*****@*****.**" || UserProfile.Email.ToLower() == "*****@*****.**")
{
await _userManager.AddToRoleAsync(user, UserRoles.Admin);
}
else
{
await _userManager.RemoveFromRoleAsync(user, UserRoles.Admin);
}
await _userManager.AddToRoleAsync(user, UserRoles.Member);
await _signInManager.RefreshSignInAsync(user);
}
try
{
await _userContext.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!UserProfileExists())
{
return(NotFound());
}
else
{
throw;
}
}
}
return(RedirectToPage("./Index"));
}
public async Task SeedAsync()
{
//_dbContext.Database.Migrate();
#region Fill Auth Db
if (!_dbContext.Roles.Any())
{
var roles = new List <ApplicationRole>()
{
new ApplicationRole()
{
Name = "admin",
NormalizedName = "Administrator",
ConcurrencyStamp = Guid.NewGuid().ToString()
},
new ApplicationRole()
{
Name = "User",
NormalizedName = "User",
ConcurrencyStamp = Guid.NewGuid().ToString()
}
};
foreach (var role in roles)
{
await _roleManager.CreateAsync(role);
}
}
if (!_dbContext.Users.Any())
{
//Add new test administrator
var admin = new ApplicationUser()
{
Email = "*****@*****.**",
UserName = "******",
FullName = "Test Admin",
JoinDate = DateTime.Now
};
var result = await _userManager.CreateAsync(admin, "Password1!");
if (result.Succeeded)
{
admin.EmailConfirmed = true;
await _userManager.UpdateAsync(admin);
var roleName = "Admin";
if (await _roleManager.RoleExistsAsync(roleName))
{
await _userManager.AddToRoleAsync(admin, roleName);
}
}
//Add new test user
var user = new ApplicationUser()
{
Email = "*****@*****.**",
UserName = "******",
FullName = "Test user",
JoinDate = DateTime.Now
};
result = await _userManager.CreateAsync(admin, "Password2!");
if (result.Succeeded)
{
admin.EmailConfirmed = true;
await _userManager.UpdateAsync(admin);
var roleName = "User";
if (await _roleManager.RoleExistsAsync(roleName))
{
await _userManager.AddToRoleAsync(admin, roleName);
}
}
}
#endregion
await CountryDbConfiguration.SeedDefaultValues(_dbContext);
await CityDbConfiguration.SeedDefaultValues(_dbContext);
await ProductCategoryDbConfiguration.SeedDefaultValues(_dbContext);
await ProductCategoryDbConfiguration.SeedDefaultValues(_dbContext);
}
public async Task <IActionResult> OnPostAsync()
{
if (!ModelState.IsValid)
{
return(Page());
}
var user = await _userManager.GetUserAsync(User);
if (user == null)
{
return(NotFound($"Unable to load user with ID '{_userManager.GetUserId(User)}'."));
}
var email = await _userManager.GetEmailAsync(user);
if (Input.Email != email)
{
var setEmailResult = await _userManager.SetEmailAsync(user, Input.Email);
if (!setEmailResult.Succeeded)
{
var userId = await _userManager.GetUserIdAsync(user);
throw new InvalidOperationException($"Unexpected error occurred setting email for user with ID '{userId}'.");
}
}
var phoneNumber = await _userManager.GetPhoneNumberAsync(user);
if (Input.PhoneNumber != phoneNumber)
{
var setPhoneResult = await _userManager.SetPhoneNumberAsync(user, Input.PhoneNumber);
if (!setPhoneResult.Succeeded)
{
var userId = await _userManager.GetUserIdAsync(user);
throw new InvalidOperationException($"Unexpected error occurred setting phone number for user with ID '{userId}'.");
}
}
if (Input.Patronymic != user.Patronymic)
{
user.Patronymic = Input.Patronymic;
await _userManager.UpdateAsync(user);
}
if (Input.FirstName != user.FirstName)
{
user.FirstName = Input.FirstName;
await _userManager.UpdateAsync(user);
}
if (Input.SecondName != user.SecondName)
{
user.SecondName = Input.SecondName;
await _userManager.UpdateAsync(user);
}
if (Input.Bio != user.Bio)
{
user.Bio = Input.Bio;
await _userManager.UpdateAsync(user);
}
if (Input.File != null)
{
var logoPath = await ImageHelper.UploadLogo(Input.File, user.Id, _hostingEnvironment);
user.Logo = logoPath;
await _userManager.UpdateAsync(user);
}
await _signInManager.RefreshSignInAsync(user);
StatusMessage = "Your profile has been updated";
return(RedirectToPage());
}
public async Task <IActionResult> OnPostAsync()
{
var user = await _userManager.GetUserAsync(User);
if (user == null)
{
return(NotFound($"Unable to load user with ID '{_userManager.GetUserId(User)}'."));
}
if (!ModelState.IsValid)
{
await LoadAsync(user);
return(Page());
}
var phoneNumber = await _userManager.GetPhoneNumberAsync(user);
var firstname = user.FirstName;
var lastname = user.LastName;
if (Input.FirstName != firstname)
{
user.FirstName = Input.FirstName;
await _userManager.UpdateAsync(user);
}
if (Input.LastName != lastname)
{
user.LastName = Input.LastName;
await _userManager.UpdateAsync(user);
}
if (Request.Form.Files.Count > 0)
{
var file = Request.Form.Files.FirstOrDefault();
using (var fs = new MemoryStream())
{
if (fs.Length < 2097152)
{
await file.CopyToAsync(fs);
user.ProfilePic = fs.ToArray();
}
else
{
ModelState.AddModelError("File", "The file is too large.");
}
}
await _userManager.UpdateAsync(user);
}
if (Input.PhoneNumber != phoneNumber)
{
var setPhoneResult = await _userManager.SetPhoneNumberAsync(user, Input.PhoneNumber);
if (!setPhoneResult.Succeeded)
{
StatusMessage = "Unexpected error when trying to set phone number.";
return(RedirectToPage());
}
}
await _signInManager.RefreshSignInAsync(user);
StatusMessage = "Your profile has been updated";
return(RedirectToPage());
}
public async Task <IActionResult> UpdateAccountAdmin(List <AdminRequest> adminList)
{
var dict = new Dictionary <String, object>();
var response = new List <AdminInfoResponse>();
var errors = new List <Error>();
foreach (var req in adminList)
{
var user = await _userManager.FindByIdAsync(req.Id);
if (user == null)
{
continue;
}
try
{
if (await _userManager.IsInRoleAsync(user, "academic management") || await _userManager.IsInRoleAsync(user, "quality assurance"))
{
if (!(user.UserName == req.Code && user.RealName == req.RealName && user.Email == req.Email && DateTime.Compare(user.DOB, Convert.ToDateTime(req.Dob)) == 0 && await _userManager.IsInRoleAsync(user, req.Role)))
{
//Update Profile
if (await _userManager.FindByEmailAsync(req.Email) != null && user.Email != req.Email)
{
errors.Add(new Error
{
Type = 1,
Message = "Email " + req.Email + " already exists",
});
continue;
}
if (await _userManager.FindByNameAsync(req.Code) != null && user.UserName != req.Code)
{
errors.Add(new Error
{
Type = 2,
Message = "Employee Code " + req.Code + " already exists",
});
continue;
}
user.UserName = req.Code;
user.RealName = req.RealName;
user.Email = req.Email;
user.DOB = Convert.ToDateTime(req.Dob);
if (!await _userManager.IsInRoleAsync(user, req.Role) && req.Role != null)
{
await _userManager.RemoveFromRoleAsync(user, (await _userManager.GetRolesAsync(user))[0]);
await _userManager.AddToRoleAsync(user, req.Role);
}
var resultUpdate = await _userManager.UpdateAsync(user);
if (resultUpdate.Succeeded)
{
response.Add(new AdminInfoResponse
{
Id = user.Id,
Code = user.UserName,
RealName = user.RealName,
Email = user.Email,
Dob = user.DOB.ToString("yyyy-MM-dd"),
Role = req.Role
});
}
else
{
return(new ObjectResult(new { type = 3, code = resultUpdate.Errors.ToList()[0].Code, message = resultUpdate.Errors.ToList()[0].Description })
{
StatusCode = 500
});
}
}
}
}
catch (Exception ex)
{
return(new ObjectResult(new { type = 4, message = ex.Message })
{
StatusCode = 500
});
}
}
dict.Add("success", response);
dict.Add("failed", errors);
return(new OkObjectResult(dict));
}
public async Task <IActionResult> Put(string id, [FromBody] string value)
{
string databaseInnerExceptionMessage = "";
var userChangeInput = JsonConvert.DeserializeObject <dynamic>(value);
List <object> messages = new List <object>();
bool status = true; //This variable is used to track the overall success of all the database operations
object response;
//http://stackoverflow.com/questions/20444022/updating-user-data-asp-net-identity
//Database is our database context set in this controller.
//I used the following 2 lines of command to create a userStore which represents AspNetUser table in the DB.
var userStore = new UserStore <ApplicationUser>(Database);
//Then, I created a userManager instance that operates on the userStore.
var userManager = new UserManager <ApplicationUser>(userStore, null, null, null, null, null, null, null, null);
//To obtain the full name information, use student.FullName.value
//To obtain the email information, use student.Email.value
var oneUser = Database.Users
.Where(item => item.Id == id).Include(p => p.Roles).FirstOrDefault();
//The following code to obtain the role name are asynchronous and not reliable.
//Doing a bypass by leveraging on the client-side JavaScript.
// var newRoleNameToAdd = identityRoleManager.FindByIdAsync(user.RoleId.Value).Result;
// var existingRoleNameToRemove = identityRoleManager.FindByIdAsync(oneUser.Roles.First().RoleId).Result;
oneUser.UserName = userChangeInput.userName;
oneUser.FullName = userChangeInput.fullName.Value;
oneUser.Email = userChangeInput.email.Value;
try
{
//Although the command below correct but violated foreign key constraint
//Must let the UserManager instance, userManager do the job.
//oneUser.Roles.FirstOrDefault().RoleId = user.roleId.Value;
//All the following 3 method calls are asynchronous. Notice that I delcared the Put method as Asynchronous method too.
//http://stackoverflow.com/questions/20444022/updating-user-data-asp-net-identity has some hints how to define the return
//type of this Put method here. Also, notice that I applied a technique to make these 3 asynchronous calls to become synchronous.
//Remove existing role from the user
var removeRoleFromUserResult = userManager.RemoveFromRoleAsync(oneUser, userChangeInput.originalRoleName.Value).Result;
//Add the new role to the user.
var addRoleToUserResult = userManager.AddToRoleAsync(oneUser, userChangeInput.selectedRoleName.Value).Result;
//Update the
var updateUserResult = userManager.UpdateAsync(oneUser).Result;
try
{
//Changes are not persisted in the database until
//I use the following command.
userStore.Context.SaveChanges();
}
catch (DbUpdateException ex)
{
databaseInnerExceptionMessage = ex.InnerException.Message;
status = false;
messages.Add(databaseInnerExceptionMessage);
}
if (removeRoleFromUserResult.Succeeded != true)
{
status = false;
messages.Add(removeRoleFromUserResult);
}
if (addRoleToUserResult.Succeeded != true)
{
status = false;
messages.Add(addRoleToUserResult);
}
if (updateUserResult.Succeeded != true)
{
status = false;
messages.Add(updateUserResult);
}
if (status == true)
{
response = new { status = "success", message = "Saved user record." };
}
else
{
response = new { status = "fail", message = messages };
}
}
catch (Exception outerException)
{
response = new { status = "fail", message = outerException.InnerException.Message };
}
return(new JsonResult(response));
}//End of Put()
public async Task <IActionResult> OnPostAsync()
{
if (!ModelState.IsValid)
{
return(Page());
}
var user = await _userManager.GetUserAsync(User);
if (user == null)
{
throw new ApplicationException($"Unable to load user with ID '{_userManager.GetUserId(User)}'.");
}
if (Input.AccountType != user.AccountType)
{
user.AccountType = Input.AccountType;
var updateAccountTypeResult = await _userManager.UpdateAsync(user);
if (!updateAccountTypeResult.Succeeded)
{
throw new ApplicationException($"Unexpected error occurred while updating the account type for user with ID '{user.Id}'.");
}
}
if (Input.CompanyName != user.CompanyName)
{
user.CompanyName = Input.CompanyName;
var updateCompanyNameResult = await _userManager.UpdateAsync(user);
if (!updateCompanyNameResult.Succeeded)
{
throw new ApplicationException($"Unexpected error occurred while updating the company name for user with ID '{user.Id}'.");
}
}
if (Input.FirstName != user.FirstName)
{
user.FirstName = Input.FirstName;
var updateFirstNameResult = await _userManager.UpdateAsync(user);
if (!updateFirstNameResult.Succeeded)
{
throw new ApplicationException($"Unexpected error occurred while updating the first name for user with ID '{user.Id}'.");
}
}
if (Input.LastName != user.LastName)
{
user.LastName = Input.LastName;
var updateLastNameResult = await _userManager.UpdateAsync(user);
if (!updateLastNameResult.Succeeded)
{
throw new ApplicationException($"Unexpected error occurred while updating the last name for user with ID '{user.Id}'.");
}
}
if (Input.ProfileImage != null)
{
using (var memoryStream = new MemoryStream())
{
await Input.ProfileImage.CopyToAsync(memoryStream);
var profileImage = memoryStream.ToArray();
if (profileImage != user.ProfileImage)
{
user.ProfileImage = profileImage;
var updateProfileImageResult = await _userManager.UpdateAsync(user);
if (!updateProfileImageResult.Succeeded)
{
throw new ApplicationException($"Unexpected error occurred while updating the profile image for user with ID '{user.Id}'.");
}
}
}
}
if (Input.DateOfBirth != user.DateOfBirth)
{
user.DateOfBirth = Input.DateOfBirth;
var updateDateOfBirthResult = await _userManager.UpdateAsync(user);
if (!updateDateOfBirthResult.Succeeded)
{
throw new ApplicationException($"Unexpected error occurred while updating the date of birth for user with ID '{user.Id}'.");
}
}
if (Input.Email != user.Email)
{
var setEmailResult = await _userManager.SetEmailAsync(user, Input.Email);
if (!setEmailResult.Succeeded)
{
throw new ApplicationException($"Unexpected error occurred setting email for user with ID '{user.Id}'.");
}
}
if (Input.PhoneNumber != user.PhoneNumber)
{
var setPhoneResult = await _userManager.SetPhoneNumberAsync(user, Input.PhoneNumber);
if (!setPhoneResult.Succeeded)
{
throw new ApplicationException($"Unexpected error occurred setting phone number for user with ID '{user.Id}'.");
}
}
StatusMessage = "Your profile has been updated";
return(RedirectToPage());
}
public async Task <IActionResult> OnPostAsync()
{
var user = await _userManager.GetUserAsync(User);
if (user == null)
{
return(NotFound($"Unable to load user with ID '{_userManager.GetUserId(User)}'."));
}
if (!ModelState.IsValid)
{
await LoadAsync(user);
return(Page());
}
var phoneNumber = await _userManager.GetPhoneNumberAsync(user);
if (Input.PhoneNumber != phoneNumber)
{
var setPhoneResult = await _userManager.SetPhoneNumberAsync(user, Input.PhoneNumber);
if (!setPhoneResult.Succeeded)
{
StatusMessage = "Unexpected error when trying to set phone number.";
return(RedirectToPage());
}
}
var firstName = user.FirstName;
var lastName = user.LastName;
if (Input.FirstName != firstName)
{
user.FirstName = Input.FirstName;
await _userManager.UpdateAsync(user);
}
if (Input.LastName != lastName)
{
user.LastName = Input.LastName;
await _userManager.UpdateAsync(user);
}
if (user.UsernameChangeLimit > 0)
{
if (Input.Username != user.UserName)
{
var userNameExists = await _userManager.FindByNameAsync(Input.Username);
if (userNameExists != null)
{
StatusMessage = "User name already taken. Select a different username.";
return(RedirectToPage());
}
var setUserName = await _userManager.SetUserNameAsync(user, Input.Username);
if (!setUserName.Succeeded)
{
StatusMessage = "Unexpected error when trying to set user name.";
return(RedirectToPage());
}
else
{
user.UsernameChangeLimit -= 1;
await _userManager.UpdateAsync(user);
}
}
}
if (Request.Form.Files.Count > 0)
{
IFormFile file = Request.Form.Files.FirstOrDefault();
user.ProfilePicture = file.OptimizeImageSize(720, 720);
await _userManager.UpdateAsync(user);
}
await _signInManager.RefreshSignInAsync(user);
StatusMessage = "Your profile has been updated";
return(RedirectToPage());
}
public async Task <IdentityResult> SaveUser(ApplicationUser user)
{
return(await _userManager.UpdateAsync(user));
}
public async Task <UsuarioData> Handle(Ejecuta request, CancellationToken cancellationToken)
{
var usuario = await userManager.FindByNameAsync(request.UserName);
if (usuario == null)
{
throw new ManejadorExcepcion(HttpStatusCode.NotFound,
new { mensaje = "No se encuentra el usuario con este UserName" });
}
var correoUsado = await context.Users.Where(x => x.Email == request.Email && x.UserName != usuario.UserName).AnyAsync();
if (correoUsado)
{
throw new ManejadorExcepcion(HttpStatusCode.InternalServerError,
new { mensaje = "No este email ya está usado por otro usuario." });
}
if (request.ImagenPerfil != null)
{
var imagenPerfilActual = await context.Documento.Where(x => x.ObjetoReferencia == new Guid(usuario.Id)).FirstOrDefaultAsync();
if (imagenPerfilActual == null)
{
var imagen = new Documento
{
Contenido = Convert.FromBase64String(request.ImagenPerfil.Data),
Nombre = request.ImagenPerfil.Nombre,
Extension = request.ImagenPerfil.Extension,
ObjetoReferencia = new Guid(usuario.Id),
DocumentoId = Guid.NewGuid(),
FechaCreacion = DateTime.UtcNow
};
context.Documento.Add(imagen);
}
else
{
imagenPerfilActual.Contenido = Convert.FromBase64String(request.ImagenPerfil.Data);
imagenPerfilActual.Nombre = request.ImagenPerfil.Nombre;
imagenPerfilActual.Extension = request.ImagenPerfil.Extension;
}
}
usuario.NombreCompleto = request.NombreCompleto;
usuario.PasswordHash = passwordHasher.HashPassword(usuario, request.Password);
usuario.Email = request.Email;
var resultado = await userManager.UpdateAsync(usuario);
var roles = await userManager.GetRolesAsync(usuario);
var listaRoles = new List <string>(roles);
var imagenPerfil = await context.Documento.Where(x => x.ObjetoReferencia == new Guid(usuario.Id)).FirstOrDefaultAsync();
ImagenGeneral imagenGeneral = null;
if (imagenPerfil != null)
{
imagenGeneral = new ImagenGeneral
{
Data = Convert.ToBase64String(imagenPerfil.Contenido),
Nombre = imagenPerfil.Nombre,
Extension = imagenPerfil.Extension
};
}
if (!resultado.Succeeded)
{
throw new Exception("No se puedo actualizar el usuario");
}
return(new UsuarioData
{
NombreCompleto = usuario.NombreCompleto,
Token = jwtGenerador.CrearToken(usuario, listaRoles),
Email = usuario.Email,
UserName = usuario.UserName,
ImagenPerfil = imagenGeneral
});
}
public async Task <bool> UpdateAsync(UserDbModel model)
{
var result = await _userManager.UpdateAsync(model);
return(result.Succeeded);
}
public async Task <ActionResult> Register(RegisterViewModel model)
{
if (ModelState.IsValid)
{
model.OtpCreated = true;
var otpValidationResult = await _otpBusinessService.IsValidOtp(Convert.ToInt32(model.OTP), Convert.ToDecimal(model.MobileNumber), (int)OtpReason.Login, DateTime.UtcNow);
if (!otpValidationResult.Succeeded)
{
model.HasError = true;
ModelState.AddModelError("", otpValidationResult.Message);
return(View(model));
}
var user = new ApplicationUser {
UserName = model.MobileNumber, Email = model.Email
};
var role = model.IsDrivingSchool? Role.DrivingSchool.ToString() : Role.Personnel.ToString();
var roleId = RoleManager.Roles.FirstOrDefault(r => r.Name == role).Id;
user.Roles.Add(new IdentityUserRole {
UserId = user.Id, RoleId = roleId
});
var result = await UserManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
model.AspNetUserId = user.Id;
var personnelResult = await CreatePersonnel(model);
if (!personnelResult.Succeeded)
{
model.HasError = true;
foreach (var error in personnelResult.Errors)
{
ModelState.AddModelError("", error);
}
return(View(model));
}
model.PersonnelId = personnelResult.Entity.PersonnelId;
user.PersonnelId = personnelResult.Entity.PersonnelId;
await UserManager.UpdateAsync(user);
if (model.IsDrivingSchool)
{
model.DrivingSchool.Mobile = Convert.ToInt64(model.MobileNumber);
model.DrivingSchool.EmailId = model.Email;
model.DrivingSchool.PersonnelId = model.PersonnelId;
var drivingSchool = await _drivingSchoolBusinessService.CreateDrivingSchool(model.DrivingSchool);
if (drivingSchool.Succeeded)
{
return(RedirectToAction("Login", "Account"));
}
ModelState.AddModelError("", drivingSchool.Exception);
foreach (var error in result.Errors)
{
ModelState.AddModelError("", error);
}
}
//await SignInManager.SignInAsync(user, isPersistent: false, rememberBrowser: false);
// For more information on how to enable account confirmation and password reset please visit http://go.microsoft.com/fwlink/?LinkID=320771
// Send an email with this link
// await UserManager.SendEmailAsync(user.Id, "Confirm your account", "Please confirm your account by clicking <a href=\"" + callbackUrl + "\">here</a>");
return(RedirectToAction("Login", "Account"));
}
model.HasError = true;
AddErrors(result);
}
// If we got this far, something failed, redisplay form
return(View(model));
}
public async Task <IActionResult> OnPostAsync()
{
var user = await _userManager.GetUserAsync(User);
if (user == null)
{
return(NotFound($"Unable to load user with ID '{_userManager.GetUserId(User)}'."));
}
if (!ModelState.IsValid)
{
await LoadAsync(user);
return(Page());
}
if (Request.Form.Files.Count > 0)
{
IFormFile file = Request.Form.Files.FirstOrDefault();
using (var dataStream = new MemoryStream())
{
await file.CopyToAsync(dataStream);
user.ProfilePicture = dataStream.ToArray();
}
await _userManager.UpdateAsync(user);
}
var phoneNumber = await _userManager.GetPhoneNumberAsync(user);
if (Input.PhoneNumber != phoneNumber)
{
var setPhoneResult = await _userManager.SetPhoneNumberAsync(user, Input.PhoneNumber);
if (!setPhoneResult.Succeeded)
{
StatusMessage = "Unexpected error when trying to set phone number.";
return(RedirectToPage());
}
}
var name = user.Name;
if (Input.Name != name)
{
user.Name = Input.Name;
await _userManager.UpdateAsync(user);
}
var address = user.Address;
if (Input.Address != address)
{
user.Address = Input.Address;
await _userManager.UpdateAsync(user);
}
var job = user.Job;
if (Input.Job != job)
{
user.Job = Input.Job;
await _userManager.UpdateAsync(user);
}
var birthdate = "2017-06-01";
if (Input.BirthDate != birthdate)
{
//user.BirthDate = Input.BirthDate;
await _userManager.UpdateAsync(user);
}
var sex = user.Sex;
if (Input.Sex != sex)
{
user.Sex = Input.Sex;
await _userManager.UpdateAsync(user);
}
var week = user.Week;
if (Input.Week != week)
{
user.Week = Input.Week;
await _userManager.UpdateAsync(user);
}
await _signInManager.RefreshSignInAsync(user);
StatusMessage = "Cập nhật thành công";
return(RedirectToPage());
}
public async Task <IActionResult> Edit(string id, [FromBody] UserEditM data)
{
var user = await _userManager.FindByIdAsync(id);
if (user == null)
{
return(NotFound(data));
}
if (user.Name != data.Name && _userManager.Users.Any(u => u.Name == data.Name))
{
ModelState.AddModelError(nameof(data.Name), nameof(Resource.NameError));
return(BadRequest(ModelState));
}
if (user.Login != data.Login && (await _userManager.FindByNameAsync(data.Login)) != null)
{
ModelState.AddModelError(nameof(data.Login), nameof(Resource.LoginError));
return(BadRequest(ModelState));
}
if (data.NewPassword.HasValue())
{
var removePasswordResult = await _userManager.RemovePasswordAsync(user);
if (!removePasswordResult.Succeeded)
{
ModelState.AddModelError(nameof(data.NewPassword), nameof(Resource.PasswordUpdateError));
removePasswordResult.Errors.ForEach(err =>
ModelState.AddModelError(nameof(data.NewPassword), $"Code {err.Code}: {err.Description}"));
return(BadRequest(ModelState));
}
var addPasswordResult = await _userManager.AddPasswordAsync(user, data.NewPassword);
if (!addPasswordResult.Succeeded)
{
ModelState.AddModelError(nameof(data.NewPassword), nameof(Resource.PasswordUpdateError));
addPasswordResult.Errors.ForEach(err =>
ModelState.AddModelError(nameof(data.NewPassword), $"Code {err.Code}: {err.Description}"));
return(BadRequest(ModelState));
}
}
var oldRole = (await _userManager.GetRolesAsync(user)).Single();
if (oldRole != data.AssignedRole)
{
if (!(await _userManager.AddToRoleAsync(user, data.AssignedRole)).Succeeded ||
!(await _userManager.RemoveFromRoleAsync(user, oldRole)).Succeeded)
{
ModelState.AddModelError(nameof(data.AssignedRole), nameof(Resource.RoleUpdateError));
return(BadRequest(ModelState));
}
}
user.Name = data.Name;
user.Login = data.Login;
user.Email = data.Email;
user.PhoneNumber = data.Phone;
user.Description = data.Description;
user.DataAccessArray = data.DataAccess.ToStringCollection();
user.Status = data.Status.Value;
if (!(await _userManager.UpdateAsync(user)).Succeeded)
{
ModelState.AddModelError(string.Empty, nameof(Resource.UserUpdateError));
return(BadRequest(ModelState));
}
await _userService.RelateUserRegionsAsync(user, data);
await _userService.RelateUserActivityCategoriesAsync(user, data);
return(NoContent());
}
public async Task <IHttpActionResult> InsertSkills(List <RegisterBindingModel> userl)
{
//if (!ModelState.IsValid)
//{
//string messages = string.Join("; ", ModelState.Values
// .SelectMany(x => x.Errors)
// .Select(x => x.ErrorMessage));
//return Json(new { success = false, issue = "", errors = messages });
//}
ZonaFl.Business.SubSystems.SUser usern = new Business.SubSystems.SUser();
ZonaFl.Business.SubSystems.SCategory usersk = new Business.SubSystems.SCategory();
ZonaFl.Business.SubSystems.SSkill sskill = new Business.SubSystems.SSkill();
RegisterBindingModel user = userl[0];
if (user.Empresa == null)
{
user.Empresa = false;
}
if (user.Freelance == null)
{
user.Freelance = false;
}
RegisterBindingModel rmb = new RegisterBindingModel();
rmb.Skills = user.Skills;
rmb.Company = user.Company;
Persistence.Entities.Company company = new Persistence.Entities.Company();
if (user.Company != null)
{
company.InjectFrom(user.Company.FirstOrDefault());
}
List <Persistence.Entities.Skill> skills = rmb.Skills.Select(e => new Persistence.Entities.Skill().InjectFrom(e)).Cast <Persistence.Entities.Skill>().ToList();
AspNetUsers aspuser = new AspNetUsers();
var useru = UserManager.FindByEmail(user.Email);
for (int i = 0; i < skills.Count(); i++)
{
ZonaFl.Persistence.Entities.Category category = null;
var skill = sskill.FindSkillByName(user.Skills[i].Name);
string[] stringSeparators = new string[] { "\n" };
string result = user.Skills[i].CategorySkill.Split(stringSeparators, StringSplitOptions.None)[0];
category = usersk.FindCategoryByName(result);
if (category == null)
{
try
{
category = usersk.InsertCategory(result);
}
catch (Exception er)
{
return(Json(new { success = false, issue = user, errors = er.Message, tipo = user, UserEmail = useru.Email }));
}
}
skills[i].IdHtml = user.Skills[i].IdHtml;
skills[i].Category = category;
skills[i].CategoryId = category.Id;
}
useru.City = user.City;
useru.Country = user.Country;
useru.UserName = user.UserName;
useru.DescUser = user.DescUser;
useru.PhoneNumber = user.PhoneNumber.ToString();
useru.FirstMiddleName = user.FirstMiddleName;
useru.Image = user.Image;
useru.Empresa = user.Empresa;
aspuser.InjectFrom(useru);
aspuser.NoTrabajadores = user.NumeroEmp;
try
{
Business.Log4NetLogger logger2 = new Business.Log4NetLogger();
if (!useru.Empresa)
{
if (skills.Count > 0)
{
skills = usern.InsertSkillsByUser(skills, aspuser);
logger2.Info("Inserción Usuario Categoria:" + useru.Id + "," + "UsuarioCategoria:" + skills.FirstOrDefault().CategoryId + ",Email:" + aspuser.Email);
}
}
}
catch (Exception er)
{
return(Json(new { success = false, issue = user, errors = er.Message, tipo = aspuser, UserEmail = useru.Email }));
}
try
{
SUser suser = new SUser();
aspuser.Empresa = useru.Empresa;
aspuser.Freelance = useru.Freelance;
IdentityResult result = await UserManager.UpdateAsync(useru);
var userupdate = suser.UpdateUser(aspuser);
if (useru.Empresa)
{
company.IdUser = useru.Id;
company.Name = userl[0].Company.Last().Name;
company.Mail = userl[0].Company.Last().Mail;
company.Site = user.UrlEmpresa;
company.Sector = userl[0].Company.Last().Sector;
company.RazonSocial = userl[0].Company.Last().RazonSocial;
company.Telefono = userl[0].Company.Last().Telefono;
company.Nit = userl[0].Company.Last().Nit;
company.NumeroEmp = aspuser.NoTrabajadores == null ? 0 : (int)aspuser.NoTrabajadores;
company.Description = userl[0].Company.Last().Description;
Persistence.Entities.Company companyp = usern.InsertCompany(company);
}
if (!result.Succeeded)
{
return(GetErrorResult(result));
}
}
catch (Exception er)
{
return(Json(new { success = false, issue = user, errors = er.Message, tipo = user, UserEmail = useru.Email }));
//return InternalServerError(er);
}
aspuser.Empresa = useru.Empresa;
aspuser.Freelance = useru.Freelance;
aspuser.Id = useru.Id;
return(Json(new { success = true, issue = user, errors = "", tipo = aspuser, UserEmail = useru.Email }));
//return Ok();
}
public async System.Threading.Tasks.Task <ActionResult> Edit(ModifyStaffViewModel staffviewmodel)
{
//checks if model is valid
if (ModelState.IsValid)
{
//checks legal working age, 16 and above
if (!(staffviewmodel.DOB.Year < DateTime.Now.Year - 16))
{
ViewBag.RoleNo = new SelectList(db.Roles, "Id", "Name");
ViewBag.ErrorMessage = "Not legal age to work";
staffviewmodel.Roles = db.Roles.Select(r => new SelectListItem {
Text = r.Name, Value = r.Name
}).ToList();
return(View(staffviewmodel));
}
//scans all instances of staff to check for pre existing staff by these details
foreach (Staff s in db.ApplicationUsers.ToList())
{
if (s.Id == staffviewmodel.tempid)
{
continue;
}
if (s.Email == staffviewmodel.Email || (s.Forename == staffviewmodel.Forename && s.Surname == staffviewmodel.Surname) || s.PhoneNumber == staffviewmodel.Telnum)
{
ViewBag.RoleNo = new SelectList(db.Roles, "Id", "Name");
ViewBag.ErrorMessage = "Staff Member Already Exists By These Details";
staffviewmodel.Roles = db.Roles.Select(r => new SelectListItem {
Text = r.Name, Value = r.Name
}).ToList();
return(View(staffviewmodel));
}
}
//finds user and previous role
var staff = UserManager.FindById(staffviewmodel.tempid);
string oldRole = (await UserManager.GetRolesAsync(staffviewmodel.tempid)).Single();
//updates details of staff
staff.Forename = staffviewmodel.Forename;
staff.Surname = staffviewmodel.Surname;
staff.DOB = staffviewmodel.DOB;
staff.Email = staffviewmodel.Email;
staff.City = staffviewmodel.City;
staff.PhoneNumber = staffviewmodel.Telnum;
staff.UserName = staff.Email;
staff.Town = staffviewmodel.Town;
staff.Street = staffviewmodel.Street;
//saves changes made
await UserManager.UpdateAsync(staff);
//removes from oldrole defined above, replaces with new role defined in staffviewmodel
await UserManager.RemoveFromRoleAsync(staffviewmodel.tempid, oldRole);
await UserManager.AddToRoleAsync(staffviewmodel.tempid, staffviewmodel.Role);
//if a password is enter into the modifyviewmodel the password is then hashed, removes previous password and add the new one to user
if (staffviewmodel.Password != null)
{
IPasswordHasher passwordHasher = new PasswordHasher();
string hashedpassword = passwordHasher.HashPassword(staffviewmodel.Password);
UserManager.RemovePassword(staffviewmodel.tempid);
await UserManager.AddPasswordAsync(staffviewmodel.tempid, staffviewmodel.Password);
db.SaveChanges();
}
//overall savechanges if password is empty
db.SaveChanges();
return(RedirectToAction("Index"));
}
//if model is not valid returns viewmodel confirming error
ViewBag.RoleNo = new SelectList(db.Roles, "Id", "Name");
ViewBag.ErrorMessage = "Submission not valid, please fill all fields";
staffviewmodel.Roles = db.Roles.Select(r => new SelectListItem {
Text = r.Name, Value = r.Name
}).ToList();
return(View(staffviewmodel));
}
public async Task AddEditEmployeesToStore(Store store, ICollection <EmployeeDto> employees)
{
var employeeRole = await _roleManager.Roles.SingleAsync(role => role.Name == "Employee");
var dbStore = await _dbLjepotaServisContext.Stores.FindAsync(store.Id);
var owner = await _userManager.GetUsersForClaimAsync(new Claim(ClaimTypes.Role, RoleHelper.Owner));
var dbEmployees = await _userManager.GetUsersForClaimAsync(new Claim("Store", dbStore.Id.ToString()));
dbEmployees = dbEmployees.Except(owner).ToList();
var newEmployees = employees.Where(employee => employee.Id == null).ToList();
employees = employees.Except(newEmployees).ToList();
foreach (var newEmployee in newEmployees)
{
var employee = newEmployee.ProjectEmployeeDtoToUser();
await _userManager.CreateAsync(employee, newEmployee.Password);
await _userManager.AddToRoleAsync(employee, employeeRole.Name);
await _userManager.AddClaimAsync(employee, new Claim("Store", store.Id.ToString()));
await _userManager.AddClaimAsync(employee, new Claim(ClaimTypes.Role, employeeRole.Name));
var userStore = new UserStore
{
Store = store,
StoreId = store.Id,
User = employee,
UserId = employee.Id,
StartOfShift = newEmployee.StartOfShift,
EndOfShift = newEmployee.EndOfShift
};
await _dbLjepotaServisContext.AddAsync(userStore);
}
foreach (var dbEmployee in dbEmployees)
{
var isEdit = employees.All(employee => employee.Id != dbEmployee.Id);
if (employees.Count == 0 && newEmployees.Count == 0)
{
isEdit = false;
}
var employeeStore = _dbLjepotaServisContext.UserStores.Single(userStore => userStore.UserId == dbEmployee.Id);
if (!isEdit)
{
_dbLjepotaServisContext.UserStores.Remove(employeeStore);
await _userManager.DeleteAsync(dbEmployee);
continue;
}
var employeeDto = employees.Single(employee => employee.Id == dbEmployee.Id);
var employeeOrNull = await _userManager.FindByIdAsync(employeeDto.Id);
if (employeeOrNull == null)
{
throw new Exception("User has ID which cannot be found in database");
}
employeeOrNull.Email = employeeDto.Email;
employeeOrNull.Firstname = employeeDto.FirstName;
employeeOrNull.Lastname = employeeDto.LastName;
employeeOrNull.Email = employeeDto.Email;
employeeOrNull.UserName = employeeDto.Username;
employeeOrNull.ImageName = employeeDto.ImageName;
employeeStore.EndOfShift = employeeDto.EndOfShift;
employeeStore.StartOfShift = employeeDto.EndOfShift;
await _userManager.UpdateAsync(employeeOrNull);
}
await _dbLjepotaServisContext.SaveChangesAsync();
}
public async Task <IdentityResult> UpdateUserAsync(UserEntity user)
{
return(await _userManager.UpdateAsync(user));
}
public async Task <IActionResult> OnPostConfirmationAsync(string returnUrl = null)
{
returnUrl = returnUrl ?? Url.Content("~/");
// Get the information about the user from the external login provider
var info = await signInManager.GetExternalLoginInfoAsync();
if (info == null)
{
ErrorMessage = "Error loading external login information during confirmation.";
return(RedirectToPage("./Login", new { ReturnUrl = returnUrl }));
}
if (ModelState.IsValid)
{
//We don't have any users yet. First should be admin.
const string AdminRole = "Administrator";
var shouldAddAdminRole = !await userManager.Users.AnyAsync();
if (shouldAddAdminRole)
{
if (!await roleManager.RoleExistsAsync(AdminRole))
{
await roleManager.CreateAsync(new IdentityRole(AdminRole));
logger.LogInformation($"Created new '{AdminRole}' role.");
}
}
var user = new XenialIdentityUser {
UserName = Input.Email, Email = Input.Email
};
var result = await userManager.CreateAsync(user);
if (result.Succeeded)
{
if (shouldAddAdminRole)
{
var roleResult = await userManager.AddToRoleAsync(user, AdminRole);
if (roleResult.Succeeded)
{
roleResult = await userManager.UpdateAsync(user);
if (roleResult.Succeeded)
{
logger.LogInformation("Added '{User}' to the '{AdminRole}' role.", user, AdminRole);
}
}
}
result = await userManager.AddLoginAsync(user, info);
if (result.Succeeded)
{
logger.LogInformation("User created an account using {Name} provider.", info.LoginProvider);
var userId = await userManager.GetUserIdAsync(user);
var code = await userManager.GenerateEmailConfirmationTokenAsync(user);
code = WebEncoders.Base64UrlEncode(Encoding.UTF8.GetBytes(code));
var callbackUrl = Url.Page(
"/Account/ConfirmEmail",
pageHandler: null,
values: new { area = "Identity", userId = userId, code = code },
protocol: Request.Scheme);
await emailSender.SendEmailAsync(Input.Email, "Confirm your email",
$"Please confirm your account by <a href='{HtmlEncoder.Default.Encode(callbackUrl)}'>clicking here</a>.");
// If account confirmation is required, we need to show the link if we don't have a real email sender
if (userManager.Options.SignIn.RequireConfirmedAccount)
{
return(RedirectToPage("./RegisterConfirmation", new { Email = Input.Email }));
}
await signInManager.SignInAsync(user, isPersistent : false, info.LoginProvider);
return(LocalRedirect(returnUrl));
}
}
foreach (var error in result.Errors)
{
ModelState.AddModelError(string.Empty, error.Description);
}
}
ProviderDisplayName = info.ProviderDisplayName;
ReturnUrl = returnUrl;
return(Page());
}
public async Task <IActionResult> OnPostAsync()
{
var user = await _userManager.GetUserAsync(User);
if (user == null)
{
return(NotFound($"Unable to load user with ID '{_userManager.GetUserId(User)}'."));
}
if (!ModelState.IsValid)
{
await LoadAsync(user);
return(Page());
}
var phoneNumber = await _userManager.GetPhoneNumberAsync(user);
if (Input.PhoneNumber != phoneNumber)
{
var setPhoneResult = await _userManager.SetPhoneNumberAsync(user, Input.PhoneNumber);
if (!setPhoneResult.Succeeded)
{
StatusMessage = "Unexpected error when trying to set phone number.";
return(RedirectToPage());
}
}
#region AddPersonalDetails
// Begin adding personal details TODO: Extract to method
if (Input.FirstName != user.FirstName)
{
user.FirstName = Input.FirstName;
}
if (Input.LastName != user.LastName)
{
user.LastName = Input.LastName;
}
if (Input.AddressLine1 != user.AddressLine1)
{
user.AddressLine1 = Input.AddressLine1;
}
if (Input.AddressLine2 != user.AddressLine2)
{
user.AddressLine2 = Input.AddressLine2;
}
if (Input.City != user.City)
{
user.City = Input.City;
}
if (Input.State != user.State)
{
user.State = Input.State;
}
if (Input.Zip != user.Zip)
{
user.Zip = Input.Zip;
}
if (Input.DateOfBirth != user.DateOfBirth)
{
user.DateOfBirth = Input.DateOfBirth;
}
if ((int)Input.Gender != (int)user.Gender)
{
user.Gender = (TroydonFitnessWebsiteUser.GenderType)Input.Gender;
}
if (Input.Height != user.Height)
{
user.Height = Input.Height;
}
if (Input.Weight != user.Weight)
{
user.Weight = Input.Weight;
}
if ((int)Input.ActivityType != (int)user.ActivityType)
{
user.ActivityType = (TroydonFitnessWebsiteUser.ActivityTypeOptions)Input.ActivityType;
}
if (Input.Bodyfat != user.Bodyfat)
{
user.Bodyfat = Input.Bodyfat;
}
#endregion
await _userManager.UpdateAsync(user);
await _signInManager.RefreshSignInAsync(user);
StatusMessage = "Your profile has been updated";
return(RedirectToPage());
}
public async Task<ActionResult> UpdateUser(string FirstName, string LastName, HttpPostedFileBase file)
{
var userId = User.Identity.GetUserId();
var manager = new UserManager<ApplicationUser>(new UserStore<ApplicationUser>(new ApplicationDbContext()));
var currentUser = manager.FindById(User.Identity.GetUserId());
if (file != null)
{
using (MemoryStream ms = new MemoryStream())
{
file.InputStream.CopyTo(ms);
byte[] array = ms.GetBuffer();
currentUser.Cover = array;
currentUser.CoverType = file.ContentType;
}
}
currentUser.LastName = LastName;
currentUser.FirstName = FirstName;
await manager.UpdateAsync(currentUser);
return View("Index");
}
void LockoutUntilYear3015(UserManager<IdentityUser> manager, IdentityUser identityUser)
{
if (identityUser != null)
{
identityUser.LockoutEnabled = true;
identityUser.LockoutEndDateUtc = DateTime.UtcNow.AddYears(999);
manager.UpdateAsync(identityUser);
}
}
public static async void ConfigureUsers(IEnumerable<InMemoryUser> users, EntityFrameworkServiceOptions options, UserManager userManager) {
using(var db = new Contexto(options.ConnectionString)) {
if(!db.Users.Any()) {
foreach(var u in users) {
var entity = new Usuario { Email = u.Claims.First(x=>x.Type==Constants.ClaimTypes.Email).Value , UserName = u.Username };
var response = await userManager.CreateAsync(entity, u.Password);
if(!response.Succeeded) {
throw new Exception("Não foi possível criar o usuario" + u.Username + response.Errors.ToString());
}
else {
var user = await userManager.FindAsync(u.Username,u.Password);
foreach(var c in u.Claims) {
await userManager.AddClaimAsync(user.Id,c);
}
await userManager.UpdateAsync(user);
}
}
db.SaveChanges();
}
}
}
public async Task <IActionResult> DeleteSureAsync(int id)
{
// TODO Defensive and check if admin is from current company.
try
{
var company = _companyRepository.GetById(id);
var currentuser = await _userManager.GetUserAsync(HttpContext.User);
company.IsDeleted = true;
company.UpdatedBy = User.Identity.Name;
company.UpdatedDate = DateTime.Now;
var response = _companyRepository.Delete(company);
if (User.IsInRole("SuperAdmin") || company.Id == currentuser.CompanyId)
{
if (response != null && response.Id != 0)
{
var BoardsInDeletedCompany = _boardRepository.GetAllBoardsfromcompany(id).ToList();
foreach (var user in company.Employees)
{
user.IsDeleted = true;
user.UpdatedBy = User.Identity.Name;
user.UpdatedDate = DateTime.Now;
await _userManager.UpdateAsync(user);
}
foreach (var board in BoardsInDeletedCompany)
{
var listoftasksinboard = board.BoardTasks.ToList();
board.IsDeleted = true;
board.UpdatedBy = User.Identity.Name;
board.UpdatedDate = DateTime.Now;
foreach (var task in listoftasksinboard)
{
task.IsDeleted = true;
task.UpdatedBy = User.Identity.Name;
task.UpdatedDate = DateTime.Now;
_taskRepository.Delete(task);
}
_boardRepository.Delete(board);
}
if (User.IsInRole("Admin"))
{
return(RedirectToAction("Logout", "Account"));
}
return(RedirectToAction("CompanyList"));
}
return(View("Delete", company));
}
return(View("NotAuthorized"));
}
catch (Exception ex)
{
_logger.LogError(ex, $"When deleting a company.");
throw;
}
}
public async Task<ActionResult> addProgressFitBit(string addProgress)
{
var userStore = new UserStore<ApplicationUser>(context);
var userManager = new UserManager<ApplicationUser>(userStore);
var currentUser = userManager.FindById(User.Identity.GetUserId());
var fitBitProgressOriginal = currentUser.FitBitProgress;
var fitBitAdd = Convert.ToInt32(addProgress);
var fitBitProgressNew = (fitBitProgressOriginal += fitBitAdd);
currentUser.FitBitProgress = fitBitProgressNew;
try
{
await userManager.UpdateAsync(currentUser);
var saveUser = userStore.Context;
await saveUser.SaveChangesAsync();
TempData["ValidationMessage"] = "Progress Added!";
}
catch
{
TempData["ValidationMessage"] = "Error: Progress Not Added!";
}
return RedirectToAction("Index");
}
public async Task <IActionResult> KullaniciDuzenle(string uyeDetayId, string uyeId, string kayitTarihi, string kullaniciAdi, string sifre, string mail, int durum, int rol, string uyeAd, string uyeSoyad)
{
try
{
if (uyeAd == null || uyeSoyad == null)
{
throw new RequiredFieldsException("Üye bilgileri boş bırakılamaz!");
}
else if (kullaniciAdi == null || sifre == null || mail == null)
{
throw new RequiredFieldsException("Kullanıcı bilgileri boş bırakılamaz!");
}
var kullanici = _uyedetayService.GetAll().Where(k => k.kullanici_adi == kullaniciAdi || k.kullanici_mail == mail).ToList();
if (kullanici.Count > 1)
{
throw new Exception("Bu kullanıcı adı / mail zaten mevcut!");
}
else
{
using (StudyCheckContext context = new StudyCheckContext())
{
using (var transaction = context.Database.BeginTransaction())
{
try
{
var oldUser = _uyedetayService.GetById(Convert.ToInt32(uyeDetayId));
var updatedUser = await _userManager.FindByNameAsync(oldUser.kullanici_adi);
if (oldUser.kullanici_sifre != sifre)
{
IdentityResult passResult = await _userManager.ChangePasswordAsync(updatedUser, oldUser.kullanici_sifre, sifre);
if (!passResult.Succeeded)
{
throw new Exception(passResult.Errors.First().Description);
}
}
updatedUser.UserName = kullaniciAdi;
updatedUser.NormalizedUserName = kullaniciAdi.ToUpper();
updatedUser.Email = mail;
updatedUser.NormalizedEmail = mail.ToUpper();
updatedUser.uyeAdi = uyeAd;
updatedUser.uyeSoyadi = uyeSoyad;
updatedUser.kullaniciAdi = kullaniciAdi;
updatedUser.kullaniciSifre = sifre;
updatedUser.kullaniciMail = mail;
updatedUser.rolId = rol;
IdentityResult result = await _userManager.UpdateAsync(updatedUser);
if (!result.Succeeded)
{
throw new Exception(result.Errors.First().Description);
}
else
{
Uye updatedUye = new Uye
{
id = Convert.ToInt32(uyeId),
uye_ad = uyeAd,
uye_soyad = uyeSoyad
};
context.Uyeler.Update(updatedUye);
context.SaveChanges();
var identityUser = await _userManager.GetUserAsync(HttpContext.User);
Uyedetay updatedKullanici = new Uyedetay
{
id = Convert.ToInt32(uyeDetayId),
kullanici_adi = kullaniciAdi,
kullanici_sifre = sifre,
kullanici_mail = mail,
kayit_tarihi = Convert.ToDateTime(kayitTarihi),
guncelleyen_id = identityUser.uyeDetayId,
guncelleme_tarihi = DateTime.Now,
uye_id = Convert.ToInt32(uyeId),
rol_id = rol,
tema_id = 1,
sil_id = durum
};
context.UyeDetay.Update(updatedKullanici);
context.SaveChanges();
}
}
catch (Exception transException)
{
transaction.Rollback();
throw new Exception(transException.Message);
}
TempData["Sonuc"] = "Kullanıcı güncellendi";
transaction.Commit();
}
}
}
}
catch (Exception ex)
{
TempData["Exception"] = ex.Message;
}
return(RedirectToAction("KullaniciListesi"));
}
public async Task<ActionResult> Edit(EditViewModel model)
{
if (ModelState.IsValid)
{
var store = new UserStore<ApplicationUser>(new ApplicationDbContext());
var manager = new UserManager<ApplicationUser>(store);
// Get the current application user
var user = UserManager.FindById(User.Identity.GetUserId());;
// Update the details
user.FirstName = model.FirstName;
user.LastName = model.LastName;
user.EMail = model.EMail;
user.City = model.City;
user.Age = model.Age;
// This is the part that doesn't work
var result = await manager.UpdateAsync(user);
var ctx = store.Context;
ctx.SaveChanges();
// However, it always succeeds inspite of not updating the database
if (!result.Succeeded)
{
AddErrors(result);
}
}
return RedirectToAction("Manage");
}
