public async Task <Result <ConnectionModel> > GetAsync(string userId, string otherId)
{
if (userId == otherId)
{
var error = Errors.UnableToGetConnectionToSelf();
return(Result <ConnectionModel> .Failure(error));
}
var connection = await _context.Set <Connection>()
.AsNoTracking()
.Include(c => c.OtherUser)
.SingleOrDefaultAsync(c => c.UserId == userId && c.OtherId == otherId);
if (connection is null)
{
var userExists = await _context.Set <User>().AnyAsync(u => u.Id == userId);
if (!userExists)
{
var error = Errors.UserNotFound(userId);
return(Result <ConnectionModel> .Failure(error));
}
var other = await _context.Set <User>()
.AsNoTracking()
.SingleOrDefaultAsync(u => u.Id == otherId);
if (other is null)
{
var error = Errors.UserNotFound(otherId);
return(Result <ConnectionModel> .Failure(error));
}
connection = new Connection {
UserId = userId, OtherId = otherId
};
_context.Set <Connection>().Add(connection);
var connectionCreatedEvent = new ConnectionCreatedIntegrationEvent(userId, otherId, other.Name, other.Tag);
await _integrationEventService.SaveEventsAndUsersContextChangesAsync(connectionCreatedEvent);
await _integrationEventService.PublishThroughEventBusAsync(connectionCreatedEvent);
_context.Entry(connection).State = EntityState.Detached;
connection.OtherUser = other;
}
var model = ConnectionModel.MapFrom(connection);
return(Result <ConnectionModel> .SuccessWith(model));
}
public async Task <Result> UpdateAsync(string id, UserUpdateModel model)
{
var user = await _context.Set <User>()
.SingleOrDefaultAsync(u => u.Id == id);
if (user is null)
{
var error = Errors.UserNotFound(id);
return(Result.Failure(error));
}
if (user.Name != model.Name)
{
user.Name = model.Name;
var tagResult = await _tagGeneratorService.GenerateAsync(id, model.Name);
if (!tagResult.Succeeded)
{
return(Result.Failure(tagResult.Errors));
}
user.Tag = tagResult.Data;
}
var userUpdatedEvent = new UserUpdatedIntegrationEvent(id, user.Name, user.Tag);
await _integrationEventService.SaveEventsAndUsersContextChangesAsync(userUpdatedEvent);
await _integrationEventService.PublishThroughEventBusAsync(userUpdatedEvent);
return(Result.Success);
}
public async Task <Result> UpdateAsync(string userId, Settings settings)
{
var user = await _context.Set <User>()
.SingleOrDefaultAsync(u => u.Id == userId);
if (user is null)
{
var error = Errors.UserNotFound(userId);
return(Result.Failure(error));
}
user.Settings = settings;
var settingsUpdatedEvent = new UserSettingsUpdatedIntegrationEvent(userId, settings.Theme);
await _integrationEventService.SaveEventsAndUsersContextChangesAsync(settingsUpdatedEvent);
await _integrationEventService.PublishThroughEventBusAsync(settingsUpdatedEvent);
return(Result.Success);
}
public async Task <Result> AddRecipientAsync(int roomId, string userToAddId, string callerId)
{
var room = await _context.Set <GroupRoom>()
.Include(r => r.Members)
.ThenInclude(m => m.User)
.Where(r => r.Members.Any(c => c.UserId == callerId))
.AsNoTracking()
.SingleOrDefaultAsync(r => r.Id == roomId);
if (room is null)
{
var error = Errors.GroupRoomNotFound(roomId);
return(Result.Failure(error));
}
if (room.Members.Count >= 10)
{
var error = Errors.GroupRoomMemberLimitExceeded(roomId);
return(Result.Failure(error));
}
var userToAdd = await _context.Set <Connection>()
.Where(c => c.UserId == callerId)
.Select(c => new
{
User = new User
{
Id = c.OtherId,
Name = c.OtherUser.Name,
Tag = c.OtherUser.Tag,
},
Relationship = c.Relationship
})
.SingleOrDefaultAsync(u => u.User.Id == userToAddId);
if (userToAdd is null)
{
var error = Errors.UserNotFound(userToAddId);
return(Result.Failure(error));
}
if (userToAdd.Relationship != RelationshipEnum.Friend)
{
var error = Errors.UnableToAddNonFriendToRoom(userToAddId);
return(Result.Failure(error));
}
var member = new Member
{
RoomId = roomId,
UserId = userToAddId
};
_context.Set <Member>().Add(member);
var memberAddedIntegrationEvent = GroupRoomMemberAddedIntegrationEvent.For(room, userToAdd.User);
await _integrationEventService.SaveEventsAndUsersContextChangesAsync(memberAddedIntegrationEvent);
await _integrationEventService.PublishThroughEventBusAsync(memberAddedIntegrationEvent);
return(Result.Success);
}
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));
}