public async Task <bool> userSave(TabUser user)
{
_bookcaseContext.TabUser.Add(user);
await _bookcaseContext.SaveChangesAsync();
return(true);
}
public async Task <bool> userUpdate(TabUser user)
{
_bookcaseContext.Entry(user).State = EntityState.Modified;
await _bookcaseContext.SaveChangesAsync();
return(true);
}
public async Task <ActionResult <TabUser> > AuthenticateUserAsync([FromBody] UserCreateDto userParam)
{
// Query verwenden, um User zu authentifizieren
//TabUser user = await _context.AuthenticateAsync(userParam.Username, userParam.Passwort);
//entsprechenden User aus der DB holen.
TabUser userDB = await
_context.TabUser.SingleOrDefaultAsync(x => x.Username == userParam.Username &&
x.Passwort == userParam.Passwort);
var User = _mapper.Map <TabUser>(userParam);
//falls ein User gefunden wurde, Passwort schwärzen bzw. unkenntlich machen.
if (User != null)
{
User.Passwort = null;
}
//wenn die Query keinen entsprechenden User zurückgibt, gibt es keinen mit dem entsprechenden
//Username und PW.
if (User == null)
{
return(BadRequest("Username oder Passwort ist falsch."));
}
//Von der Query erhaltenen User zurückgeben.
return(Ok(User));
}
public async Task <ActionResult> Post([FromBody] TabUser user)
{
var saved = await _userService.userSave(user);
if (!saved)
{
return(BadRequest("Email or username is being used."));
}
return(Ok(saved));
}
public async Task <bool> userUpdate(TabUser user)
{
var oldUser = await _userRepository.userTakeById(user.UserId);
if (oldUser == null)
{
return(false);
}
user.UserPassword = oldUser.UserPassword;
return(await _userRepository.userUpdate(user));
}
public static async Task <TabUser> GetUserAsync(this IDataContext context, int id)
{
//entsprechenden User aus der DB holen
TabUser user = await context.TabUser.SingleOrDefaultAsync(x =>
x.Id == id);
//falls ein User gefunden wurde, Passwort schwärzen bzw. unkenntlich machen
if (user != null)
{
user.Passwort = null;
}
//User zurückgeben
return(user);
}
public static async Task <TabUser> AuthenticateAsync(this IDataContext context, string username, string passwort)
{
//entsprechenden User aus der DB holen
TabUser user = await
context.TabUser.SingleOrDefaultAsync(x => x.Username == username &&
x.Passwort == passwort);
//falls ein User gefunden wurde, Passwort schwärzen bzw. unkenntlich machen
if (user != null)
{
user.Passwort = null;
}
//User zurückgeben
return(user);
}
public async Task <bool> userSave(TabUser user)
{
var userByUsername = await _userRepository.userTakeByUsername(user.UserName);
if (userByUsername != null)
{
return(false);
}
var userByEmail = await _userRepository.userTakeByEmail(user.UserEmail);
if (userByEmail != null)
{
return(false);
}
return(await _userRepository.userSave(user));
}
public static async Task <bool> DeleteUserAsync(this IDataContext context, int id)
{
//entsprechenden User aus der DB holen
TabUser userDB = await context.TabUser.SingleOrDefaultAsync(x =>
x.Id == id);
//falls ein User gefunden wurde, diesen Löschen
if (userDB != null)
{
context.TabUser.Remove(userDB);
//await context.SaveChangesAsynchron();
return(true);
}
//es gibt keinen entsprechenden User
return(false);
}
public async Task <ActionResult <UserReadDto> > GetUserAsync(int id)
{
//Claims in der erzeugten Identity können hier verwendet werden
//-> User können nur ihre eigenen Daten abrufen
if (id != Convert.ToInt16(User.FindFirst(ClaimTypes.NameIdentifier).Value) &&
!User.IsInRole(Role.ADMIN)) // Admins können jeden User abrufen
{
return(Forbid());
}
TabUser user = await _context.GetUserAsync(id);
if (user == null)
{
return(NotFound("Der User existiert nicht."));
}
return(Ok(_mapper.Map <UserReadDto>(user)));
}
public async Task <ActionResult> AuthUser([FromBody] AuthUser authUser)
{
TabUser user = await _userService.authUser(authUser);
if (user == null)
{
return(BadRequest("Senha ou email inválidos!"));
}
var claims = new[]
{
new Claim("id", user.UserId.ToString()),
new Claim("userName", user.UserName),
new Claim("fullName", user.UserFullName),
new Claim("email", user.UserEmail)
};
var key = new SymmetricSecurityKey(Encoding.UTF8.GetBytes(_configuration["SecurityKey"]));
var creds = new SigningCredentials(key, SecurityAlgorithms.HmacSha256);
var token = new JwtSecurityToken(
issuer: "Code Cave Web Solution",
audience: user.UserEmail,
claims: claims,
expires: DateTime.Now.AddMinutes(1),
signingCredentials: creds
);
Response.Headers.Add("x-access-token", new JwtSecurityTokenHandler().WriteToken(token));
return(Ok());
//return Ok(new
//{
// token = new JwtSecurityTokenHandler().WriteToken(token)
//});
}
public async Task <ActionResult <TabUser> > UpdateUserAsync(int id, [FromBody] UserUpdateDto userParam)
{
if (userParam == null || id != userParam.Id)
{
return(BadRequest("Irgendetwas ist schief gelaufen! Geben Sie die Parameter erneut ein."));
}
//Claims in der erzeugten Identity können hier verwendet werden
//-> User können nur ihre eigenen Daten abrufen
if (id != Convert.ToInt16(User.FindFirst(ClaimTypes.NameIdentifier).Value) &&
!User.IsInRole(Role.ADMIN)) // Admins können jeden User ändern
{
return(Forbid("Das ist Ihnen nicht erlaubt!"));
}
//TabUser user = await _context.UpdateUserdataAsync(userParam);
//entsprechenden User aus der DB holen.
TabUser userDB = await _context.TabUser.SingleOrDefaultAsync(u =>
u.Id == userParam.Id);
//falls ein User gefunden wurde, dessen Daten aktualisieren.
if (userDB != null)
{
//prüfen, ob der Username geändert wurde.
if (userDB.Username != userParam.Username)
{
//prüfen, ob der neue Username noch frei ist.
bool usernameVorhanden = await _context.TabUser.AnyAsync(x =>
x.Username == userParam.Username);
if (usernameVorhanden)
{
return(null);
}
//neuen Usernamen übernehmen
userDB.Username = userParam.Username;
}
//prüfen, ob die Rolle geändert wurde
if (userDB.Role != userParam.Role)
{
//falls keine gültige Rolle angegeben wurde,
//bekommt der neue User die Rolle "user"
string userParamRole = userParam.Role.Trim().ToLower();
if (!Role.IsValid(userParam.Role))
{
userParam.Role = Role.USER;
}
}
_mapper.Map(userParam, userDB);
//Daten werden aktualisiert
userDB.Vorname = userParam.Vorname;
userDB.Nachname = userParam.Nachname;
userDB.Id = userParam.Id;
userDB.Passwort = userParam.Passwort;
userDB.Username = userParam.Username;
userDB.Vegetarier = userParam.Vegetarier;
userDB.Veganer = userParam.Veganer;
userDB.Glutenfrei = userParam.Glutenfrei;
await _context.SaveChangesAsynchron();
return(NoContent());
}
return(NotFound("Der User existiert nicht!"));
}
