public ICollection <User> GetAll()
{
var entities = userRepository.SelectAll().ToList();
var mapped = entities.Select(x => userMapper.Map(x)).ToList();
var sorted = mapped.OrderBy(x => x.Name).ToList();
return(sorted);
}
public async Task <UserResponse> LogInAsync(LogInRequest req)
{
var user = await _repo.GetAsync(req.UserName);
if (user == null)
{
throw new KeyNotFoundException($"Could not find username: {req.UserName}");
}
if (user.Password == req.Password)
{
return(_mapper.Map(user));
}
//TODO: Generate TOKEN and update date...
return(null);
}
public User Authenticate(string name, string password)
{
var user = userRepository.SelectByName(name);
if (user != null && passwordService.VerifyPassword(password, user.Password))
{
return(userMapper.Map(user));
}
return(null);
}
public UserDTO GetUserByEmail(string email)
{
UserDTO user = null;
using var connection = Common.GetConnection();
using var command = SQL_GET_USER_BY_EMAIL(email);
command.Connection = connection;
connection.Open();
using var reader = command.ExecuteReader();
while (reader.Read())
{
user = _userMapper.Map(reader);
}
connection.Close();
return(user);
}
public RegisterResponse Register(RegisterRequest request)
{
var response = new RegisterResponse();
var authenticationResponse = _authenticator.For(request.Authenticator).Authenticate(new AuthenticationRequest
{
Token = request.UserToken
});
if (authenticationResponse.HasError)
{
response.AddError(authenticationResponse.Error);
return(response);
}
var createUserResponse = _userRepository.CreateUser(new CreateUserRequest
{
User = new UserModel
{
UserToken = authenticationResponse.UserId,
Username = authenticationResponse.Username,
Picture = authenticationResponse.Picture
}
});
if (createUserResponse.HasError && createUserResponse.Error.Code != ErrorCodes.UserAlreadyExists)
{
response.AddError(createUserResponse.Error);
return(response);
}
var getUserResponse = _userRepository.GetUser(authenticationResponse.UserId);
if (getUserResponse.HasError)
{
response.AddError(getUserResponse.Error);
return(response);
}
response.User = _userMapper.Map(getUserResponse.User);
return(response);
}
public AuthResponse Register(RegisterRequest model, string ipAddress)
{
UserDTO user = _userMapper.Map(model);
_userRepository.CreateUser(user);
var createdUser = _userRepository.GetUserByEmail(user.Email);
var jwtToken = GenerateJwtToken(createdUser.Id);
var refreshToken = GenerateRefreshToken(ipAddress, createdUser.Id);
_refreshTokenRepository.SaveRefreshToken(refreshToken);
return(new AuthResponse(createdUser, jwtToken, refreshToken.Token));
}
public TransferScript Map(Script script)
{
if (script == null)
{
return(null);
}
TransferScript transferScript = new TransferScript
{
ScriptId = script.ScriptId,
Title = script.Title,
CreatedDate = script.CreatedDate,
Description = script.Description,
LastEditedDate = script.LastEditedDate,
OperatorId = script.OperatorId,
PrompterId = script.PrompterId,
OptionsId = script.OptionsId,
Operator = _userMapper.Map(script.Operator),
Prompter = _userMapper.Map(script.Prompter),
Options = _optionsMapper.Map(script.Options),
EntityState = EntityState.Unchanged
};
if (script.Sections != null)
{
transferScript.Sections =
script.Sections
.Select(section => _sectionMapper.Map(section))
.ToList();
}
return(transferScript);
}
public string Add(UserModel userModel)
{
userModel.Token = Membership.GeneratePassword(128, 0);
MailMessage mail = new MailMessage("*****@*****.**", userModel.Email);
SmtpClient client = new SmtpClient("smtp.gmail.com");
client.Port = 587;
client.Credentials = new System.Net.NetworkCredential("*****@*****.**", "a1a2a3a4a5a6!");
client.EnableSsl = true;
mail.Subject = "Your " + userModel.Type + " account token";
mail.Body = "Your " + userModel.Type + " account has been created!\n Use the following token to register: " + userModel.Token;
client.Send(mail);
uRepo.Add(uMapper.Map(userModel));
return(userModel.Token);
}
public List <DealModel> Map(List <DealRecord> dealRecords, string userIdentifier)
{
var response = new List <DealModel>();
foreach (var dealRecord in dealRecords)
{
var positiveVotes = dealRecord.Votes.Where(x => x.Positive).ToList().Count;
var negativeVotes = dealRecord.Votes.Where(x => !x.Positive).ToList().Count;
response.Add(new DealModel
{
Id = dealRecord.Identifier,
Title = dealRecord.Title,
Summary = dealRecord.Summary,
DistanceInMeters = dealRecord.DistanceInMeters,
CreatedAt = dealRecord.CreatedAt,
Location = new Location
{
Longitude = dealRecord.Longitude,
Latitude = dealRecord.Latitude
},
User = _userMapper.Map(dealRecord.User),
Votes = new VoteDetailsModel
{
TotalVotes = dealRecord.Votes.Count,
PositiveVotes = positiveVotes,
NegativeVotes = negativeVotes,
FinalScore = positiveVotes - negativeVotes,
HasAlreadyVoted = dealRecord.Votes.Any(x => x.User.Identifier.ToString() == userIdentifier)
},
Tags = dealRecord.DealTags.ConvertAll(x => x.Tag.Name),
Expired = dealRecord.Expired
});
}
return(response);
}
public User GetUser(int id)
{
var user = _context.Users.Find(id);
return(user == null ? null : _userMapper.Map(user));
}
public IList <TransferUser> Get()
{
return(_userService.FetchAllPrompters()
.Select(prompter => _userMapper.Map(prompter))
.ToList());
}
public void addUser(Models.UserModel userModel)
{
userModel.Password = BCrypt.Net.BCrypt.HashPassword(userModel.Password);
_databaseContext.Users.Add(_userMapper.Map(userModel));
_databaseContext.SaveChanges();
}
