public async Task <User> CreateUserAsync(string name, string email, decimal monthlySalary, decimal monthlyExpenses)
{
var entity = new User()
{
Name = name,
Email = email,
MonthlyExpenses = monthlyExpenses,
MonthlySalary = monthlySalary,
DateCreated = DateTime.Now
};
await _usersContext.AddAsync(entity);
await _usersContext.SaveChangesAsync();
return(entity);
}
public async Task AddAsync(User user)
{
if (user == null)
{
throw new ArgumentNullException(nameof(user));
}
if (_context.Users.FirstOrDefault(u => u.Email == user.Email) != null)
{
throw new Exception("User with such email is already registered");
}
var hashedPwd = _hasher.HashPassword(user, user.Password);
user.Password = hashedPwd;
user.IsActive = true;
await _context.AddAsync(user);
_context.SaveChanges();
}
public async Task <Result <RoomModel> > CreateAsync(string userId, string[] othersIds)
{
var othersCount = othersIds.Length;
if (othersCount == 0 || othersCount > 9)
{
var error = Errors.InvalidOtherUsersCount(othersCount);
return(Result <RoomModel> .Failure(error));
}
var user = await _context.Set <User>()
.SingleOrDefaultAsync(u => u.Id == userId);
if (user is null)
{
var error = Errors.UserNotFound(userId);
return(Result <RoomModel> .Failure(error));
}
var otherUsers = await _context.Set <Connection>()
.Include(u => u.OtherUser)
.Where(u => u.UserId == userId)
.Where(u => othersIds.Contains(u.OtherId))
.Where(u => u.Relationship == RelationshipEnum.Friend)
.ToListAsync();
var errors = new List <string>();
foreach (var otherId in othersIds)
{
var otherUserExists = otherUsers.Exists(r => r.OtherId == otherId);
if (!otherUserExists)
{
var error = Errors.UnableToAddNonFriendToRoom(otherId);
errors.Add(error);
}
}
if (errors.Count > 0)
{
return(Result <RoomModel> .Failure(errors.ToArray()));
}
Room room;
if (othersCount < 2)
{
var otherId = othersIds.First();
var roomExists = await _context.Set <Room>()
.Where(r => r.Type == RoomType.Private)
.Where(r => r.Members.Any(m => m.UserId == userId))
.Where(r => r.Members.Any(m => m.UserId == otherId))
.AnyAsync();
if (roomExists)
{
var error = Errors.PrivateRoomAlreadyExists(userId, otherId);
return(Result <RoomModel> .Failure(error));
}
room = new Room();
}
else
{
room = new GroupRoom()
{
OwnerId = userId
};
}
await _context.AddAsync(room);
_context.Set <Member>().Add(new Member {
RoomId = room.Id, UserId = userId
});
foreach (var other in otherUsers)
{
var member = new Member
{
RoomId = room.Id,
UserId = other.OtherId
};
_context.Set <Member>().Add(member);
}
await _context.SaveChangesAsync();
var roomCreatedEvent = RoomCreatedIntegrationEvent.For(room);
await _integrationEventService.SaveEventsAndUsersContextChangesAsync(roomCreatedEvent);
await _integrationEventService.PublishThroughEventBusAsync(roomCreatedEvent);
var model = RoomModel.MapFrom(room);
return(Result <RoomModel> .SuccessWith(model));
}
public async Task Add(UserDao user)
{
await _usersContext.AddAsync(user);
await _usersContext.SaveChangesAsync();
}
