public IActionResult Post([FromBody] TaskFront value)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var userId = userManager.GetUserId(HttpContext.User);
Console.WriteLine("UserID: " + userId);
UserTask newTask = new UserTask();
AplicationUser appUser = _context.Users.Find(userId);
Console.WriteLine("User found email: " + appUser.Email);
newTask.AplicationUser = appUser;
newTask.Deadline = value.Deadline;
newTask.Title = value.Title;
newTask.Type = Models.Type.next;
_context.UserTasks.Update(newTask);
_context.SaveChanges();
return(Ok());
}
public async Task <IActionResult> Create([Bind("BiljeskaId,Datum,AplicationUserId,AktivnostId,Biljeske")] Biljeska biljeska)
{
if (ModelState.IsValid)
{
_context.Add(biljeska);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
var username = HttpContext.User.Identity.Name;
var vjeroucitelj = await userManager.FindByNameAsync(username);
var vjerouciteljId = vjeroucitelj.Id;
var users = (from u in _context.VjerouciteljUcenik
where u.VjerouciteljId == vjerouciteljId
select u.UcenikId).ToList();
var ucenici = new AplicationUser();
foreach (var id in users)
{
var user = await userManager.FindByIdAsync(id);
ucenici.Ucenici.Add(user);
}
ViewData["AktivnostId"] = new SelectList(_context.Aktivnosti, "AktivnostId", "Naziv", biljeska.AktivnostId);
ViewData["AplicationUserId"] = new SelectList(ucenici.Ucenici, "AplicationUserId", "Email", biljeska.AplicationUserId);
return(View(biljeska));
}
public async Task <IActionResult> EditProfile(AplicationUser model)
{
if (!ModelState.IsValid)
{
return(View("~/Views/MyProfile/EditProfile.cshtml", model));
}
var userFromDb = await _userManager.FindByIdAsync("model.Id");
userFromDb.Name = model.Name;
userFromDb.Surname = model.Surname;
userFromDb.Email = model.Email;
userFromDb.Location = model.Location;
userFromDb.Phone = model.Phone;
userFromDb.Password = model.Password;
var result = await _userManager.UpdateAsync(userFromDb);
if (!result.Succeeded)
{
ModelState.AddModelError("User", "Error,user data not updated!");
return(View("~/Views/MyProfile/EditProfile.cshtml", userFromDb));
}
return(RedirectToAction("Index"));
}
private void CreateUser(string email, string fullName, string pass, BlogDbContext context)
{
var userManager = new UserManager <AplicationUser>(
new UserStore <AplicationUser>(context));
userManager.PasswordValidator = new PasswordValidator()
{
RequireDigit = false,
RequiredLength = 1,
RequireLowercase = false,
RequireNonLetterOrDigit = false,
RequireUppercase = false
};
var admin = new AplicationUser()
{
Email = email,
FullName = fullName,
UserName = email
};
var result = userManager.Create(admin, pass);
if (!result.Succeeded)
{
throw new Exception(string.Join(";", result.Errors));
}
}
public ActionResult Register(Register model)
{
if (ModelState.IsValid)
{
//Kayıt işlemleri
var user = new AplicationUser();
user.Name = model.Name;
user.Surname = model.Surname;
user.Email = model.Email;
user.UserName = model.UserName;
IdentityResult result =
userManager.Create(user, model.Password);
if (result.Succeeded)
{
//kullanıcıyı role ata
if (roleManager.RoleExists("user"))
{
userManager.AddToRole(user.Id, "user");
}
return(RedirectToAction("Login", "Account"));
}
else
{
ModelState.AddModelError("RegisterUserError", "Kullanıcı oluşturma hatası.");
}
}
return(View(model));
}
public async Task <IActionResult> Create(RegisterModel model)
{
if (ModelState.IsValid)
{
AplicationUser user = new AplicationUser();
user.UserName = model.UserName;
user.Email = model.Email;
var result = await userManger.CreateAsync(user, model.Password);
if (result.Succeeded)
{
return(RedirectToAction("Index"));
}
else
{
foreach (var item in result.Errors)
{
ModelState.AddModelError("", item.Description);
}
}
}
return(View(model));
}
public ActionResult Login([FromBody]UsuarioDTO usuarioDTO)
{
ModelState.Remove("Nome");
ModelState.Remove("ConfimacaoSenha");
if (ModelState.IsValid)
{
AplicationUser usuario = _usuarioRepository.Obter(usuarioDTO.Email, usuarioDTO.Senha);
if (usuario != null)
{
return GerarToken(usuario);
}
else
{
return NotFound("Usuario não localizado");
}
}
else
{
return UnprocessableEntity(ModelState);
}
}
public ActionResult Cadastrar([FromBody]UsuarioDTO usuarioDTO)
{
if (ModelState.IsValid)
{
AplicationUser usuario = new AplicationUser();
usuario.FullName = usuarioDTO.Nome;
usuario.Email = usuarioDTO.Email;
usuario.UserName = usuarioDTO.Email;
var resultado = _userManager.CreateAsync(usuario, usuarioDTO.Senha).Result;
if (!resultado.Succeeded)
{
List<string> erros = new List<string>();
foreach (var erro in resultado.Errors)
{
erros.Add(erro.Description);
}
return UnprocessableEntity(erros);
}
else
{
return Ok(usuario);
}
}
else
{
return UnprocessableEntity(ModelState);
}
}
public async Task <IActionResult> Register(RegisterViewModel model)
{
if (ModelState.IsValid)
{
var user = new AplicationUser()
{
UserName = model.Email, Email = model.Email, City = model.City
};
var result = await userManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
if (signInManager.IsSignedIn(User) && User.IsInRole("Admin"))
{
return(RedirectToAction("ListUsers", "Administration"));
}
await signInManager.SignInAsync(user, isPersistent : false);
return(RedirectToAction("Index", "Home"));
}
foreach (var error in result.Errors)
{
ModelState.AddModelError("", error.Description);
}
}
return(View());
}
private TokenDTO BuildToken(AplicationUser usuario)
{
var claims = new[]
{
new Claim(JwtRegisteredClaimNames.Email, usuario.Email),
new Claim(JwtRegisteredClaimNames.Sub, usuario.Id),
};
var key = new SymmetricSecurityKey(Encoding.UTF8.GetBytes("chave-api-jwt-minhas-tarefas"));
var sign = new SigningCredentials(key, SecurityAlgorithms.HmacSha256);
var exp = DateTime.UtcNow.AddHours(1);
JwtSecurityToken token = new JwtSecurityToken(
issuer: null,
audience: null,
claims: claims,
expires: exp,
signingCredentials: sign
);
var refreshToken = Guid.NewGuid().ToString();
var tokenString = new JwtSecurityTokenHandler().WriteToken(token);
var expRefreshToken = DateTime.UtcNow.AddHours(2);
var tokenDTO = new TokenDTO { Token = tokenString, Expiration = exp, ExpirationRefreshToken = expRefreshToken, RefreshToken = refreshToken };
return tokenDTO;
}
private List <Role> GetUserRoles(AplicationUser user, BlogDbContext context)
{
// Create user and role managers
var userManager = new UserManager <AplicationUser>(
new UserStore <AplicationUser>(context));
var roleManager = new RoleManager <IdentityRole>(
new RoleStore <IdentityRole>(context));
// Get all application roles
var roles = roleManager.Roles
.Select(r => r.Name)
.OrderBy(r => r)
.ToList();
// For each application role, check if the user has it
var userRoles = new List <Role>();
foreach (var roleName in roles)
{
var role = new Role {
Name = roleName
};
if (userManager.IsInRole(user.Id, roleName))
{
role.IsSelected = true;
}
userRoles.Add(role);
}
// Return a list with all roles
return(userRoles);
}
public async Task <IActionResult> Register(AplicationUser model)
{
if (ModelState.IsValid)
{
var userExist = await _userManager.FindByEmailAsync(model.Email);
if (userExist != null)
{
ModelState.AddModelError("Email", "User with this email exists");
return(View("Index", model));
}
var user = model;
user.UserName = model.Email;
IdentityResult result = await _userManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
return(Redirect("/Login"));
}
else
{
ModelState.AddModelError("User", "User registration failed");
return(View("Index", model));
}
}
return(View("Index", model));
}
async Task AddToRoleAdmin(AplicationUser user)
{
if (!await _roleManager.RoleExistsAsync("Admin"))
{
await _roleManager.CreateAsync(new IdentityRole("Admin"));
}
await _userManager.AddToRoleAsync(user, "Admin");
}
public List <UserTask> GetAllUserTask(AplicationUser user)
{
//if default tasks not contain default_user_task add it
if (!StorageModel.UserTasks.Exists(x => x.Id == AppConstants.DEFAULT_USER_TASK.Id))
{
StorageModel.UserTasks.Add(AppConstants.DEFAULT_USER_TASK);
Save();
}
GetStatistics();
return(StorageModel.UserTasks);
}
public async Task <IActionResult> OnPostAsync(string returnUrl = null)
{
returnUrl = returnUrl ?? Url.Content("~/");
ExternalLogins = (await _signInManager.GetExternalAuthenticationSchemesAsync()).ToList();
if (ModelState.IsValid)
{
var user = new AplicationUser {
UserName = Input.Email, Email = Input.Email, IsAdmin = Input.IsAdmin, Name = Input.Name
};
var result = await _userManager.CreateAsync(user, Input.Password);
if (result.Succeeded)
{
_logger.LogInformation("User created a new account with password.");
if (user.IsAdmin)
{
await AddToRoleAdmin(user);
_logger.LogInformation("User Added to admin group");
}
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 = user.Id, code = code, returnUrl = returnUrl },
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 (_userManager.Options.SignIn.RequireConfirmedAccount)
{
return(RedirectToPage("RegisterConfirmation", new { email = Input.Email, returnUrl = returnUrl }));
}
else
{
await _signInManager.SignInAsync(user, isPersistent : false);
return(LocalRedirect(returnUrl));
}
}
foreach (var error in result.Errors)
{
ModelState.AddModelError(string.Empty, error.Description);
}
}
// If we got this far, something failed, redisplay form
return(Page());
}
public List <Tarefa> Resturacao(AplicationUser usuario, DateTime dataUltimaSincronizacao)
{
var query = _banco.Tarefas.Where(a => a.UsuarioId == usuario.Id).AsQueryable();
if (dataUltimaSincronizacao != null)
{
query.Where(a => a.Criado >= dataUltimaSincronizacao || a.Atualizado >= dataUltimaSincronizacao);
}
return(query.ToList <Tarefa>());
}
public async Task <IActionResult> Create(/*[Bind("PrisutnostId,Datum,AplicationUserId,AktivnostId,IsPrisutan")]*/ VjerouciteljListaPrisutnosti prisutnosti)
{
if (ModelState.IsValid)
{
foreach (var prisutnost in prisutnosti.UceniciIsSelected)
{
if (prisutnost.IsSelected == true)
{
var user = await userManager.FindByEmailAsync(prisutnost.Ucenik);
var tempPrisutnost = new Prisutnost
{
AktivnostId = prisutnosti.TempPrisutnost.AktivnostId,
PrisutnostId = prisutnosti.TempPrisutnost.PrisutnostId,
AplicationUserId = user.AplicationUserId,
IsPrisutan = prisutnosti.TempPrisutnost.IsPrisutan,
Datum = prisutnosti.TempPrisutnost.Datum
};
_context.Add(tempPrisutnost);
}
else
{
ViewBag.Error = $"Niste odabrali nijednog ucenika!";
}
}
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
var username = HttpContext.User.Identity.Name;
var vjeroucitelj = await userManager.FindByNameAsync(username);
var vjerouciteljId = vjeroucitelj.Id;
var users = (from u in _context.VjerouciteljUcenik
where u.VjerouciteljId == vjerouciteljId
select u.UcenikId).ToList();
var ucenici = new AplicationUser();
foreach (var id in users)
{
var user = await userManager.FindByIdAsync(id);
ucenici.Ucenici.Add(user);
}
ViewData["AktivnostId"] = new SelectList(_context.Aktivnosti, "AktivnostId", "Naziv", prisutnosti.TempPrisutnost.AktivnostId);
ViewData["AplicationUserId"] = new SelectList(ucenici.Ucenici, "AplicationUserId", "ImeIPrezime", prisutnosti.UceniciIsSelected);
var enumPrisutnost = Enum.GetValues(typeof(IsPrisutan)).Cast <IsPrisutan>().Select(v => v.ToString()).ToList();
ViewData["Prisutnost"] = new SelectList(enumPrisutnost);
return(View(prisutnosti));
}
private async Task LoadAsync(AplicationUser user)
{
var email = await _userManager.GetEmailAsync(user);
Email = email;
Input = new InputModel
{
NewEmail = email,
};
IsEmailConfirmed = await _userManager.IsEmailConfirmedAsync(user);
}
public void Post([FromBody] UserSignUp value)
{
var userManager = serviceProvider.GetRequiredService <UserManager <AplicationUser> >();
AplicationUser user = new AplicationUser()
{
Email = value.email,
SecurityStamp = Guid.NewGuid().ToString(),
UserName = value.username
};
userManager.CreateAsync(user, value.password);
}
private async Task LoadAsync(AplicationUser user)
{
var userName = await _userManager.GetUserNameAsync(user);
var phoneNumber = await _userManager.GetPhoneNumberAsync(user);
Username = userName;
Input = new InputModel
{
PhoneNumber = phoneNumber
};
}
public void Cadastrar(AplicationUser usuario, string senha)
{
var result = _userManager.CreateAsync(usuario, senha).Result;
if (!result.Succeeded)
{
StringBuilder sb = new StringBuilder();
foreach (var error in result.Errors)
{
sb.Append(error.Description);
}
throw new Exception($"Usuário não localizado! {sb.ToString()}");
}
}
public async Task <ActionResult <UserToken> > CreateUser([FromBody] UserInfo model)
{
var user = new AplicationUser {
UserName = model.Email, Email = model.Email
};
var result = await _userManager.CreateAsync(user, model.Password);
if (result.Succeeded)
{
return(BuildToken(model, new List <string>()));
}
else
{
return(BadRequest("Username or password invalid"));
}
}
private ActionResult GerarToken(AplicationUser usuario)
{
var token = BuildToken(usuario);
var tokenModel = new Token()
{
RefreshToken = token.RefreshToken,
ExpirationToken = token.Expiration,
ExpirationRefreshToken = token.ExpirationRefreshToken,
Usuario = usuario,
Criado = DateTime.Now,
Utilizado = false,
};
_tokenRepository.Cadastrar(tokenModel);
return Ok(token);
}
// GET: Prisutnost/Create
public async Task <IActionResult> Create()
{
var username = HttpContext.User.Identity.Name;
var vjeroucitelj = await userManager.FindByNameAsync(username);
var vjerouciteljId = vjeroucitelj.Id;
var users = (from u in _context.VjerouciteljUcenik
where u.VjerouciteljId == vjerouciteljId
select u.UcenikId).ToList();
var ucenici = new AplicationUser();
var temp = new List <PrisutnostVjeroucitelj>();
foreach (var id in users)
{
var user = await userManager.FindByIdAsync(id);
ucenici.Ucenici.Add(user);
var prisutnostVjeroucitelja = new PrisutnostVjeroucitelj
{
Ucenik = user.Email,
IsSelected = false,
};
temp.Add(prisutnostVjeroucitelja);
}
var prisutnost = new Prisutnost();
var vjerouciteljListaPrisutnosti = new VjerouciteljListaPrisutnosti();
vjerouciteljListaPrisutnosti.UceniciIsSelected = temp;
vjerouciteljListaPrisutnosti.OdaberiSve = false;
vjerouciteljListaPrisutnosti.TempPrisutnost = prisutnost;
var vjerouciteljaktivnosti = _context.Predaje.Where(p => p.VjerouciteljId == vjerouciteljId).ToList();
ViewData["AktivnostId"] = new SelectList(vjerouciteljaktivnosti, "AktivnostId", "NazivPredmeta");
ViewData["AplicationUserId"] = new SelectList(ucenici.Ucenici, "AplicationUserId", "Email");
var enumPrisutnost = Enum.GetValues(typeof(IsPrisutan)).Cast <IsPrisutan>().Select(v => v.ToString()).ToList();
ViewData["Prisutnost"] = new SelectList(enumPrisutnost);
return(View(vjerouciteljListaPrisutnosti));
}
private async Task LoadSharedKeyAndQrCodeUriAsync(AplicationUser user)
{
// Load the authenticator key & QR code URI to display on the form
var unformattedKey = await _userManager.GetAuthenticatorKeyAsync(user);
if (string.IsNullOrEmpty(unformattedKey))
{
await _userManager.ResetAuthenticatorKeyAsync(user);
unformattedKey = await _userManager.GetAuthenticatorKeyAsync(user);
}
SharedKey = FormatKey(unformattedKey);
var email = await _userManager.GetEmailAsync(user);
AuthenticatorUri = GenerateQrCodeUri(email, unformattedKey);
}
private void SetUserRoles(AplicationUser user, BlogDbContext db, EditUserViewModel model)
{
var userManager = Request
.GetOwinContext()
.GetUserManager <ApplicationUserManager>();
foreach (var role in model.Roles)
{
if (role.IsSelected)
{
userManager.AddToRole(user.Id, role.Name);
}
else if (!role.IsSelected)
{
userManager.RemoveFromRole(user.Id, role.Name);
}
}
}
public async Task <IActionResult> Register(RegisterViewModel register)
{
if (!ModelState.IsValid)
{
return(View("Comprobacion", register));
}
if (ModelState.IsValid)
{
var user = new AplicationUser
{
NombreUsuario = register.NombreUsuario,
UserName = register.NombreUsuario,
Email = register.NombreUsuario,
Contraseña = register.Contraseña
};
var result = await _userManager.CreateAsync(user);
if (result.Succeeded)
{
await _signInManager.SignInAsync(user, false);
return(RedirectToAction("Index", "Home"));
}
else
{
//foreach (var error in result.Errors)
//{
// ModelState.AddModelError("", error.Description);
//}
return(View("Comprobacion", register));
}
}
return(View(register));
}
public async Task <ActionResult> Register(RegisterViewModel model)
{
if (ModelState.IsValid)
{
var user = new AplicationUser
{
UserName = model.Email,
FullName = model.FullName,
Email = model.Email
};
var result = await UserManager.CreateAsync(user, model.Password);
using (var db = new BlogDbContext())
{
var userId = db.Users.FirstOrDefault((u => u.Email.Equals(user.Email))).Id;
this.UserManager.AddToRole(userId, "User");
}
var addRoleResult = UserManager.AddToRole(user.Id, "User");
if (result.Succeeded)
{
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, "Confirm your account", "Please confirm your account by clicking <a href=\"" + callbackUrl + "\">here</a>");
return(RedirectToAction("Index", "Home"));
}
AddErrors(result);
}
// If we got this far, something failed, redisplay form
return(View(model));
}
public async Task <IActionResult> ListUsers()
{
var username = HttpContext.User.Identity.Name;
var vjeroucitelj = await userManager.FindByNameAsync(username);
var vjerouciteljId = vjeroucitelj.Id;
var users = (from u in _context.VjerouciteljUcenik
where u.VjerouciteljId == vjerouciteljId
select u.UcenikId).ToList();
var ucenici = new AplicationUser();
foreach (var id in users)
{
var user = await userManager.FindByIdAsync(id);
ucenici.Ucenici.Add(user);
}
return(View(ucenici.Ucenici));
}
public async Task <IActionResult> Login(LoginViewModel login)
{
var valores = ModelState.Values;
var noseque = ModelState.ValidationState;
if (!ModelState.IsValid)
{
return(View("../Account/Comprobacion", login));
}
ViewBag.Title = "Login page";
if (ModelState.IsValid)
{
var user = new AplicationUser
{
NombreUsuario = login.NombreUsuario,
UserName = login.NombreUsuario,
Email = login.NombreUsuario,
Contraseña = login.Contraseña
};
var result = await _signInManager.PasswordSignInAsync(user, login.Contraseña, login.RememberMe, false);
if (result.Succeeded)
{
Identidad = user.Id;
return(RedirectToAction("Index", "Home", Identidad));
}
else
{
ModelState.AddModelError("", "Error en Login");
}
}
return(View(login));
}
