public async Task <AppUserDTO> Register(AppUserRegisterDTO appUserRegisterDTO)
{
var appUserDTO = new AppUserDTO();
if (await _context.Users.Where(x => x.Email == appUserRegisterDTO.Email).AnyAsync())
{
appUserDTO.Message.Add("Email already in system");
}
if (await _context.Users.Where(x => x.UserName == appUserRegisterDTO.UserName).AnyAsync())
{
appUserDTO.Message.Add("User Name already in system");
}
var newUser = new AppUser
{
DisplayName = appUserRegisterDTO.UserName,
Email = appUserRegisterDTO.Email,
UserName = appUserRegisterDTO.UserName
};
var newUserResult = await _userManager.CreateAsync(newUser, appUserRegisterDTO.Password);
if (newUserResult.Succeeded)
{
appUserDTO.DisplayName = newUser.DisplayName;
appUserDTO.Token = _jwtGenerator.CreateToken(newUser);
appUserDTO.UserName = newUser.UserName;
appUserDTO.Image = null;
}
else
{
foreach (var Error in newUserResult.Errors)
{
appUserDTO.Message.Add(Error.Description);
}
}
return(appUserDTO);
}
public async Task <User> Handle(Query request, CancellationToken cancellationToken)
{
var user = await _userManager.FindByNameAsync(_userAccessor.GetCurrentUserName());
return(new User
{
DisplayName = user.DisplayName,
UserName = user.UserName,
ModalityId = user.ModalityId,
RefreshToken = user.RefreshToken,
Token = _jwtGenerator.CreateToken(user)
});
}
public async Task <UsuarioDto> Handle(UsuarioActualCommand request, CancellationToken cancellationToken)
{
var usuario = await _userManager.FindByNameAsync(_usuarioSesion.GetUsuarioSesion());
if (usuario != null)
{
var usuarioDTO = _mapper.Map <Usuario, UsuarioDto>(usuario);
usuarioDTO.Token = _jwtGenerator.CreateToken(usuario);
return(usuarioDTO);
}
throw new Exception("No se encontro el usuario");
}
public async Task <User> Handle(Query request,
CancellationToken cancellationToken)
{
var user = await _userManager.FindByNameAsync(_userAccessor.GetCurrentUsername());
return(new User
{
DisplayName = user.DisplayName,
Username = user.UserName,
Token = _jwtGenerator.CreateToken(user),
Image = null
});
}
public async Task <User> Handle(Query request, CancellationToken cancellationToken)
{
// handler logic goes here
var user = await _userManager.FindByNameAsync(_userAccessor.GetCurrentUserName());
return(new User
{
DisplayName = user.DisplayName,
UserName = user.UserName,
Token = _jwtGenerator.CreateToken(user),
Image = user.Photos.FirstOrDefault(x => x.IsMain)?.Url
});
}
public async Task <User> Handle(Query request, CancellationToken cancellationToken)
{
//my code goes here
var user = await _userManager
.FindByNameAsync(_userAccessor.GetCurrentUserName());
return(new User
{
FullName = user.FirstName + " " + user.LastName,
UserName = user.UserName,
Token = _jwtGenerator.CreateToken(user),
});
}
public async Task <User> Handle(Query request,
CancellationToken cancellationToken)
{
var userInfo = await _facebookAccessor
.FacebookLogin(request.AccessToken);
if (userInfo == null)
{
throw new RestException(HttpStatusCode.BadRequest,
new { User = "******" });
}
var user = await _userManager.FindByEmailAsync(
userInfo.Email);
if (user == null)
{
user = new AppUser
{
DisplayName = userInfo.Name,
Id = userInfo.Id,
Email = userInfo.Email,
UserName = "******" + userInfo.Id
};
var photo = new Photo
{
Id = "fb_" + userInfo.Id,
Url = userInfo.Picture.Data.Url,
IsMain = true
};
user.Photos.Add(photo);
var result = await _userManager.CreateAsync(user);
if (!result.Succeeded)
{
throw new RestException(HttpStatusCode.BadRequest,
new { User = "******" });
}
}
return(new User
{
DisplayName = user.DisplayName,
Token = _jwtGenerator.CreateToken(user),
Username = user.UserName,
Image = user.Photos.FirstOrDefault(x => x.IsMain)?.Url
});
}
public async Task <User> Handle(Query request, CancellationToken cancellationToken)
{
// get user info and verify token is valid
var userInfo = await _facebookAccessor.FacebookLogin(request.AccessToken);
// if user info is null then token could not be validated
if (userInfo == null)
{
throw new RestException(HttpStatusCode.BadRequest, new { User = "******" });
}
var user = await _userManager.FindByEmailAsync(userInfo.Email);
if (user == null)
{
user = new AppUser
{
DisplayName = userInfo.FirstName,
Id = userInfo.Id,
Email = userInfo.Email,
UserName = "******" + userInfo.Id,
RefreshToken = _jwtGenerator.GenerateRefreshToken(),
RefreshTokenExpiry = DateTime.Now.AddDays(30)
};
var photo = new Photo
{
Id = Guid.NewGuid().ToString(),
Url = userInfo.Picture.Data.Url,
IsMain = true
};
user.Photos.Add(photo);
var result = await _userManager.CreateAsync(user);
if (!result.Succeeded)
{
throw new RestException(HttpStatusCode.BadRequest, new { User = "******" });
}
}
return(new User
{
DisplayName = user.DisplayName,
Token = _jwtGenerator.CreateToken(user),
RefreshToken = user.RefreshToken,
Username = user.UserName,
Image = user.Photos.FirstOrDefault(x => x.IsMain)?.Url
});
}
public async Task <User> Handle(Command request, CancellationToken cancellationToken)
{
var countVal = _context.Users.Count();
var rank = AppUserRank.None;
if (countVal == 0)
{
rank = AppUserRank.Admin;
}
else
{
if (await _context.Users.Where(x => x.Email == request.Email).AnyAsync())
{
throw new RestException(HttpStatusCode.BadRequest, new { Email = "Email already exists!" });
}
if (await _context.Users.Where(x => x.UserName == request.Username).AnyAsync())
{
throw new RestException(HttpStatusCode.BadRequest, new { Username = "******" });
}
}
var user = new AppUser
{
DisplayName = request.DisplayName,
Email = request.Email,
UserName = request.Username,
Rank = rank
};
try {
var result = await _userManager.CreateAsync(user, request.Password);
if (result.Succeeded)
{
return(new User
{
Id = user.Id,
DisplayName = user.DisplayName,
Token = _jwtGenerator.CreateToken(user),
Username = user.UserName,
Rank = user.Rank
});
}
} catch (Exception e) {
Console.WriteLine("User creation error: ", e);
throw new RestException(HttpStatusCode.NotFound, new { User = "******" });
}
throw new RestException(HttpStatusCode.NotFound, new { User = "******" });
}
public async Task <User> Handle(Command request, CancellationToken cancellationToken)
{
var normalizedEmail = request.Email.ToUpper();
var normalizedUsername = request.Username.ToUpper();
if (await _context.Users.AnyAsync(u => u.NormalizedEmail == normalizedEmail))
{
throw new RestException(HttpStatusCode.BadRequest, ErrorType.DuplicateEmailFound);
}
if (await _context.Users.AnyAsync(u => u.NormalizedUserName == normalizedUsername))
{
throw new RestException(HttpStatusCode.BadRequest, ErrorType.DuplicateUsernameFound);
}
var user = new AppUser
{
DisplayName = request.DisplayName,
Email = request.Email,
UserName = request.Username,
RefreshToken = _jwtGenerator.GenerateRefreshToken(),
RefreshTokenExpiry = DateTime.Now.AddDays(30),
NotificationsEmail = request.Email,
};
var result = await _userManager.CreateAsync(user, request.Password);
if (result.Succeeded)
{
return(new User
{
DisplayName = user.DisplayName,
Email = user.Email,
Username = user.UserName,
Token = _jwtGenerator.CreateToken(user),
RefreshToken = user.RefreshToken,
NotificationsEmail = user.NotificationsEmail,
NotifyAboutCertificateChange = user.NotifyAboutCertificateChange,
ExpiryNotificationThreshold = user.ExpiryNotificationThresholdDays,
NotifyAboutExpiryIfRenewalConfigured = user.NotifyAboutExpiryIfRenewalConfigured,
RenewalThresholdDays = user.RenewalThresholdDays
});
}
throw new RestException(HttpStatusCode.InternalServerError, ErrorType.SavingChangesError);
}
public async Task <UserModel> Handle(Query request, CancellationToken cancellationToken)
{
var user = await _userManager.FindByNameAsync(_userAccessor.GetCurrentUsername());
IList <string> role = await _userManager.GetRolesAsync(user);
return(new UserModel
{
Mail = user.Email,
Username = user.UserName,
Token = _jwtGenerator.CreateToken(user),
Role = role[0],
});
}
public async Task <UserDTO> Login(UserLoginDTO userLoginDTO)
{
var user = await _userManager.FindByEmailAsync(userLoginDTO.Email);
if (user == null)
{
return(null);
}
var userResult = await _signInManager.CheckPasswordSignInAsync(user, userLoginDTO.Password, false);
if (userResult.Succeeded)
{
return(new UserDTO
{
DisplayName = user.DisplayName,
Token = _jwtGenerator.CreateToken(user),
UserName = user.UserName
});
}
return(null);
}
public async Task <UserDto> Handle(Query request, CancellationToken cancellationToken)
{
var user = await _userManager.FindByNameAsync(_userAccessor.GetCurrentUsername());
var image = await _context.Photos.FirstOrDefaultAsync(p => p.AppUserId == user.Id && p.IsMain);
return(new UserDto
{
DisplayName = user.DisplayName,
Username = user.UserName,
Token = _jwtGenerator.CreateToken(user),
Image = image?.Url
});
}
public async Task <User> Handle(Query request, CancellationToken cancellationToken)
{
var user = await _userManager.FindByNameAsync(_userAccessor.GetCurrentUsername());
return(new User
{
FirstName = user.FirstName,
LastName = user.LastName,
Username = user.UserName,
// Not necessary, but is used to give the user a new token without the need to log in if they have closed and reopened their browser
Token = _jwtGenerator.CreateToken(user),
Image = null
});
}
public async Task <IActionResult> Login(UserForLoginDto UserForLogin)
{
var user = await _userManager.FindByEmailAsync(UserForLogin.Email);
if (user is null)
{
return(Unauthorized());
}
var result = await _signInManager
.CheckPasswordSignInAsync(user, UserForLogin.Password, false);
if (!result.Succeeded)
{
return(Unauthorized());
}
return(Ok(new UserToReturnForAuthDto
{
Token = _jwtGenerator.CreateToken(user),
Username = user.UserName,
}));
}
public async Task <User> Handle(Query request, CancellationToken cancellationToken)
{
var user = await _userManager.FindByNameAsync(_userAccessor.GetCurrentUsername());
return(new User
{
UserName = user.UserName,
FirstName = user.FirstName,
LastName = user.LastName,
Email = user.Email,
Token = _jwtGenerator.CreateToken(user),
Role = user.Role,
});
}
public async Task <UserDto> Handle(Command request, CancellationToken cancellationToken)
{
if (await _dataContext.Users.Where(x => x.Email == request.Email).AnyAsync())
{
throw new RestException(HttpStatusCode.BadRequest, new { message = "Email already exist" });
}
if (await _dataContext.Users.Where(x => x.UserName == request.Email).AnyAsync())
{
throw new RestException(HttpStatusCode.BadRequest, new { message = "UserName already exist" });
}
var user = new User
{
UserName = request.Email,
Email = request.Email,
Role = request.Role
};
var result = await _userManager.CreateAsync(user, request.Password);
if (result.Succeeded)
{
if (request.Role.ToLower() == "doctor")
{
_dataContext.Doctors.Add(new Domain.Doctor {
User = user
});
}
;
if (request.Role.ToLower() == "pacient")
{
_dataContext.Pacients.Add(new Pacient {
User = user
});
}
var success = await _dataContext.SaveChangesAsync(cancellationToken) > 0;
if (success)
{
return(new UserDto
{
Token = _jwtGenerator.CreateToken(user),
});
}
}
throw new Exception("Problem with saving changes");
}
public async Task <User> Handle(Query request, CancellationToken cancellationToken)
{
//User accessor called the method to retrieve the username from the token
var user = await _userManager.FindByNameAsync(_userAccessor.GetCurrentUsername());
return(new User
{
Username = user.UserName,
FirstName = user.FirstName,
LastName = user.LastName,
PhoneNumber = user.PhoneNumber,
Token = _jwtGenerator.CreateToken(user)
});
}
public async Task <User> Handle(Query request, CancellationToken cancellationToken)
{
var username = _userAccessor.GetCurrentUsername();
var user = await _userManager.FindByNameAsync(username);
return(new User
{
DisplayName = user.DisplayName,
Username = user.UserName,
Token = _jwtGenerator.CreateToken(user),
Image = user.Photos.SingleOrDefault(p => p.IsMain)?.Url
});
}
public async Task <User> Login(UserLoginVm loginVm)
{
try
{
new MailAddress(loginVm.Email);
}
catch
{
throw new ArgumentException("Value has a invalid format.", nameof(loginVm.Email));
}
if (string.IsNullOrWhiteSpace(loginVm.Password))
{
throw new ArgumentException("Value can't be null or empty.", nameof(loginVm.Password));
}
var user = await _userManager.FindByEmailAsync(loginVm.Email);
if (user == null)
{
throw new UnauthorizedAccessException("User doesn't exist.");
}
var result = await _signInManager.CheckPasswordSignInAsync(user, loginVm.Password, false);
if (result.Succeeded)
{
return(new User()
{
Email = user.Email,
Username = user.UserName,
Token = _jwtGenerator.CreateToken(user)
});
}
throw new UnauthorizedAccessException("Password is invalid.");
}
public async Task <LoggedInfo> Handle(Command request, CancellationToken cancellationToken)
{
if (await _context.Users.Where(x => x.Email == request.Email).AnyAsync())
{
throw new RestException(HttpStatusCode.BadRequest, new { Email = "Email address already in use" });
}
if (await _context.Users.Where(x => x.UserName == request.Username).AnyAsync())
{
throw new RestException(HttpStatusCode.BadRequest, new { Email = "Username already in use" });
}
var person = new Person
{
Id = request.Id,
Lastname = request.Lastname,
Firstname = request.Firstname,
Middlename = request.Middlename,
Gender = request.Gender,
Address = request.Address
};
var role = _context.Roles.Where(x => x.Name == Constant.Customer);
var user = new AppUser
{
Email = request.Email,
Fullname = Utility.FormatName(person),
UserName = request.Username,
Person = person,
Role = _context.Roles.Where(x => x.Name == (request.isRetailer ? "Retailer" : "Customer")).FirstOrDefault()
};
var register = await _userManager.CreateAsync(user, request.Password);
if (register.Succeeded)
{
return(new LoggedInfo
{
DisplayName = user.Fullname,
Username = user.UserName,
Image = null,
Token = _jwtGenerator.CreateToken(user),
Role = user.Role.Name
});
}
throw new Exception("Registration Failed");
}
public async Task <User> Handle(ExternalLoginQuery request, CancellationToken cancellationToken)
{
var userInfo = await _facebookAccessor.FacebookLogin(request.AccessToken);
if (userInfo == null)
{
throw new RestException(HttpStatusCode.BadRequest, new { User = "******" });
}
var user = await _userManager.FindByEmailAsync(userInfo.Email);
if (user != null && !user.EmailConfirmed)
{
throw new RestException(HttpStatusCode.BadRequest, new { Login = "******" });
}
if (user == null)
{
user = new AppUser
{
DisplayName = userInfo.Name,
Id = userInfo.Id,
Email = userInfo.Email,
UserName = "******" + userInfo.Id,
RefreshToken = _jwtGenerator.GenerateRefreshToken(),
RefreshTokenExpiry = DateTime.Now.AddDays(30)
};
var photo = new Photo
{
Id = "fb_" + userInfo.Id,
Url = userInfo.Picture.Data.Url,
IsMain = true
};
user.Photos.Add(photo);
var result = await _userManager.CreateAsync(user);
if (!result.Succeeded)
{
throw new RestException(HttpStatusCode.BadRequest, new { User = "******" });
}
}
return(new User
{
DisplayName = user.DisplayName,
Token = _jwtGenerator.CreateToken(user),
RefreshToken = user.RefreshToken,
Id = user.Id,
Image = user.Photos.FirstOrDefault(x => x.IsMain)?.Url
});
}
public async Task <AppUser> Handle(Query request, CancellationToken cancellationToken)
{
var email = _userAccessor.GetCurrentUsername();
User user = new User();
MySqlConnection connection = new MySqlConnection("Database=daedalusdb; Data Source=projectdaedalus.mysql.database.azure.com; User Id=daedalus@projectdaedalus; Password=xDEvk7Cr");
using (connection)
{
string sqlQuery = $"SELECT * FROM appuser WHERE email = '" + email + "'";
MySqlCommand command = new MySqlCommand(sqlQuery, connection);
try
{
connection.Open();
command.Prepare();
MySqlDataReader reader = command.ExecuteReader();
while (reader.Read())
{
user.Email = reader["Email"].ToString();
user.Id = reader["Id"].ToString();
user.FirstName = reader["FirstName"].ToString();
user.LastName = reader["LastName"].ToString();
user.Role = Convert.ToInt32(reader["Role"]);
}
reader.Close();
}
catch (Exception e)
{
Console.WriteLine(e.ToString());
connection.Close();
}
connection.Close();
}
return(new AppUser
{
Token = _jwtGenerator.CreateToken(user),
Id = user.Id,
Email = user.Email,
FirstName = user.FirstName,
LastName = user.LastName,
Role = user.Role,
// Username = user.UserName,
Image = null
});
}
public async Task <User> SignIn(LoginAuth login)
{
var user = await _userManager.FindByEmailAsync(login.Email);
if (user == null)
{
throw new RestException(HttpStatusCode.Unauthorized);
}
var result = await _signInManager
.CheckPasswordSignInAsync(user, login.Password, false);
if (result.Succeeded)
{
//generate token
return(new User
{
DisplayName = user.DisplayName,
Token = _jwtGenerator.CreateToken(user),
Username = user.UserName,
});
}
throw new RestException(HttpStatusCode.Unauthorized);
}
public async Task <UserVm> Handle(CurrentUserQuery request, CancellationToken cancellationToken)
{
var user = await _userManager.FindByIdAsync(_currentUserService.UserId);
var roles = await _userManager.GetRolesAsync(user);
return(new UserVm
{
Id = user.Id,
Token = await _jwtGenerator.CreateToken(user),
Username = user.UserName,
IsClient = await _userManager.IsInRoleAsync(user, RolesEnum.Client),
Roles = roles
});
}
public async Task <AuthUserData> Handle(Current request, CancellationToken cancellationToken)
{
var user = await _userManager.FindByNameAsync(_userSession.GetUserSession());
var roles = (await _userManager.GetRolesAsync(user)).ToList();
return(new AuthUserData
{
FullName = user.FullName,
Username = user.UserName,
Email = user.Email,
Token = _jwtGenerator.CreateToken(user, roles),
Image = null
});
}
public async Task <LoginViewModel> Handle(LoginQuery request, CancellationToken cancellationToken)
{
var user = await _requestHelper.SendRequest(_authSettings.Url, request.Password, request.Username);
if (!user.Success)
{
_notification.AddNotification("Usuário", "Usuario ou senha incorretos");
return(null);
}
return(new LoginViewModel
{
Token = _jwtGenerator.CreateToken()
});
}
public async Task <User> Handle(Query request, CancellationToken cancellationToken)
{
var user = await _userManager.FindByNameAsync(_userAccessor.GetCurrentUsername());
var following = user.Followings.Select(f => f.Target).ToList();
var followers = user.Followers.Select(f => f.Observer).ToList();
return(new User
{
DisplayName = user.DisplayName,
Username = user.UserName,
Token = _jwtGenerator.CreateToken(user),
Image = user.Photos.FirstOrDefault(p => p.IsMainPhoto)?.Url
});
}
public async Task <User> Handle(Query request, CancellationToken cancellationToken)
{
var user = await _userManager.Users
.Include(x => x.Images)
.SingleOrDefaultAsync(x => x.UserName == _userAccessor.GetCurrentUsername());
return(new User
{
DisplayName = user.DisplayName,
Username = user.UserName,
Token = _jwtGenerator.CreateToken(user),
Image = user.Images.FirstOrDefault(x => x.IsMain)?.Url,
Locale = user.Locale
});
}
public async Task <User> Handle(Query request, CancellationToken cancellationToken)
{
var user = await _userManager.FindByNameAsync(_userAccessor.GetCurrentUserName());
if (user == null)
{
throw new RestException(HttpStatusCode.Unauthorized);
}
return(new User
{
Username = user.UserName,
DisplayName = user.DisplayName,
Token = _jwtGenerator.CreateToken(user),
Image = null
});
}