/// <summary>
/// загрузит все чего не хватает, истории только актуальные
/// </summary>
/// <param name="roomDb"></param>
/// <returns></returns>
private async Task <Room> GetRoomFromDbObject(PlaningRoomDal roomDb)
{
if (roomDb == null)
{
return(null);
}
var storedRoom = new StoredRoom
{
Name = roomDb.Name,
Password = roomDb.Password,
Id = roomDb.Id,
Stories = (await _storyRepository.GetActualForRoom(roomDb.Id)).Select(x =>
{
var st = new Story();
st.FromDbObject(x);
return(st);
}).ToList()
};
await _roomRepository.LoadUsers(roomDb);
storedRoom.Users = //(await _planingUserRepository.GetForRoom(roomDb.Id))
roomDb.Users.Select(x =>
{
var st = new PlanitUser();
st.FromDbObject(x);
return(st);
}).ToList();
return(new Room(storedRoom));
}
//----------------------------------------------------------------------------------private------------------
/// <summary>
/// рума уже создана и добавлена, пользователь еще нет
/// </summary>
/// <param name="room"></param>
/// <param name="user"></param>
/// <returns></returns>
private async Task <bool> EnterInRoom(Room room, PlanitUser user)
{
if (room == null || user == null)
{
return(false);
}
//var username = user.Name;
var userConnectionId = user.UserConnectionId;
var userId = user.PlaningAppUserId;
var mainAppUserId = user.MainAppUserId;
var(sc, oldConnectionId) = await _planitPokerService.AddUserIntoRoom(room, user);
if (!sc)
{
throw new SomeCustomException(ErrorConsts.SomeError);
}
if (!string.IsNullOrWhiteSpace(oldConnectionId))
{
var roomName = room.GetConcurentValue(_multiThreadHelper, rm => rm.StoredRoom.Name);
await Groups.RemoveFromGroupAsync(oldConnectionId, roomName.res);
await Clients.Client(oldConnectionId)
.SendAsync(Consts.PlanitPokerHubEndpoints.UserLeaved, new List <string>()
{
userId
});
}
var roomnm = room.GetConcurentValue(_multiThreadHelper, x => x.StoredRoom.Name);
if (!roomnm.sc)
{
throw new SomeCustomException(ErrorConsts.SomeError);
}
//специально до добавления юзера в руму сигнала тк ему это сообщение не нужно
var us = GetValueFromRoomAsync(room,
(rm) => rm.StoredRoom.Users.FirstOrDefault(x => x.UserConnectionId == userConnectionId));
if (!us.sc || us.res == null)
{
throw new SomeCustomException(ErrorConsts.SomeError);
}
var returnUser = new PlanitUserReturn(us.res);
await Clients.Group(roomnm.res).SendAsync(Consts.PlanitPokerHubEndpoints.NewUserInRoom, returnUser);
await Groups.AddToGroupAsync(userConnectionId, roomnm.res);
await Clients.Caller.SendAsync(Consts.PlanitPokerHubEndpoints.EnteredInRoom, userId,
userId == mainAppUserId?.ToString()); //,usersInRoom//todo мб лучше отдельным запросом?
return(true);
}
// ReSharper disable once UnusedMember.Global
public async Task EnterInRoom(string roomName, string password, string username)
{
roomName = NormalizeRoomName(roomName);
username = ValidateString(username);
var httpContext = Context.GetHttpContext();
await _apiHealper.DoStandartSomething(async() =>
{
if (string.IsNullOrWhiteSpace(password))
{
password = null;
}
else
{
password = _hasher.GetHash(password);
}
if (string.IsNullOrEmpty(roomName))
{
_errorService.AddError(_errorContainer.TryGetError(Consts.PlanitPokerErrorConsts.RoomNameIsEmpty));
await _apiHealper.NotifyFromErrorService();
await Clients.Caller.SendAsync(Consts.PlanitPokerHubEndpoints.ConnectedToRoomError);
}
var room = await _planitPokerService.TryGetRoom(roomName, password);
if (room == null)
{
throw new SomeCustomException(Consts.PlanitPokerErrorConsts.RoomNotFound);
}
UserInfo userInfo = null;
var expired = false;
try
{
(expired, userInfo) =
_apiHealper.GetUserInfoWithExpired(Context.GetHttpContext().Request, _jwtService, false);
}
catch
{
}
if (expired && userInfo != null)
{
//не прерываем процесс подключения, но сообщаем о том что нужен рефреш
await Clients.Caller.SendAsync(Consts.PlanitPokerHubEndpoints.NeedRefreshTokens);
}
var user = new PlanitUser()
{
MainAppUserId = userInfo?.UserId,
PlaningAppUserId = GenerateUniqueUserId(),
UserConnectionId = GetConnectionId(),
Name = username,
Role = GetDefaultRoles(),
};
_ = await EnterInRoom(room, user);
}, httpContext.Response, _logger);
}
// ReSharper disable once UnusedMember.Global
public async Task CreateRoom(string roomName, string password, string username)
{
var httpContext = Context.GetHttpContext();
await _apiHealper.DoStandartSomething(async() =>
{
roomName = NormalizeRoomName(roomName);
username = ValidateString(username);
if (string.IsNullOrWhiteSpace(password))
{
password = null;
}
else
{
password = _hasher.GetHash(password);
}
UserInfo userInfo = null;
var expired = false;
try
{
(expired, userInfo) =
_apiHealper.GetUserInfoWithExpired(httpContext.Request, _jwtService, false);
}
catch
{
}
if (expired && userInfo != null)
{
//не прерываем процесс создания румы, но сообщаем о том что нужен рефреш
await Clients.Caller.SendAsync(Consts.PlanitPokerHubEndpoints.NeedRefreshTokens);
}
var user = new PlanitUser()
{
MainAppUserId = userInfo?.UserId,
PlaningAppUserId = GenerateUniqueUserId(),
UserConnectionId = GetConnectionId(),
Name = username,
Role = GetCreatorRoles(),
};
var room = await _planitPokerService.CreateRoomWithUser(roomName, password, user);
if (room == null)
{
await Clients.Caller.SendAsync(Consts.PlanitPokerHubEndpoints.RoomNotCreated);
return;
}
_ = await EnterInRoom(room, user);
}, httpContext.Response, _logger);
}
public PlanitUserReturn(PlanitUser obj)
{
if (obj == null)
{
return;
}
UserIdentifier = obj.PlaningAppUserId;
Roles = obj.Role;//obj.IsAdmin,//obj.Role.Contains();
Name = obj.Name;
Vote = obj.Vote;
HasVote = obj.HasVote;
}
private async Task <bool> UpdateUserIfCan(string roomName, string userId, string userConnectionIdRequest,
Func <PlanitUser, bool> userChange)
{
//возможно объеденить с UpdateIfCan
var room = await TryGetRoom(roomName);
if (room == null)
{
throw new SomeCustomException(Consts.PlanitPokerErrorConsts.RoomNotFound);
}
if (string.IsNullOrWhiteSpace(userId))
{
return(false);
}
bool result = false;
room.SetConcurentValue <Room>(_multiThreadHelper, rm =>
{
var user = rm.StoredRoom.Users.FirstOrDefault(x => x.UserConnectionId == userConnectionIdRequest);
if (user == null || !user.IsAdmin)
{
throw new SomeCustomException(Consts.PlanitPokerErrorConsts.DontHaveAccess);
}
if (userId != user.PlaningAppUserId)
{
user = rm.StoredRoom.Users.FirstOrDefault(x => x.PlaningAppUserId == userId);
if (user == null)
{
throw new SomeCustomException(Consts.PlanitPokerErrorConsts.PlanitUserNotFound);
}
}
result = userChange(user);
});
ThrowBySuccess(result);
return(result);
}
public async Task <(PlanitUser user, bool sc)> KickFromRoom(Room room, string userConnectionIdRequest,
string userId)
{
if (string.IsNullOrWhiteSpace(userId))
{
throw new SomeCustomException(Consts.PlanitPokerErrorConsts.PlanitUserNotFound);
}
if (room == null)
{
throw new SomeCustomException(Consts.PlanitPokerErrorConsts.RoomNotFound);
}
PlanitUser user = null;
var rs = await UpdateIfCan(room, userConnectionIdRequest, (rm) =>
{
//rm.Users.RemoveAt((int)userForDelIndex);
user = rm.Users.FirstOrDefault(x => x.PlaningAppUserId == userId);
rm.Users.RemoveAll(x => x.PlaningAppUserId == userId);
return(Task.FromResult(true));
});
return(user, rs);
}
public async Task <Room> CreateRoomWithUser(string roomName, string password, PlanitUser user)
{
if (string.IsNullOrWhiteSpace(roomName))
{
throw new SomeCustomException(Consts.PlanitPokerErrorConsts.RoomNameIsEmpty);
}
if (user == null)
{
throw new SomeCustomException(Consts.PlanitPokerErrorConsts.PlanitUserNotFound);
}
if (string.IsNullOrWhiteSpace(password))
{
password = null;
}
if (Rooms.ContainsKey(roomName))
{
throw new SomeCustomException(Consts.PlanitPokerErrorConsts.RoomAlreadyExist);
}
var roomData = new StoredRoom(roomName, password);
var room = new Room(roomData);
var roomFromDb = await _roomRepository.Exist(roomName);
if (roomFromDb) // != null
{
throw new SomeCustomException(Consts.PlanitPokerErrorConsts.RoomAlreadyExist);
}
var added = Rooms.TryAdd(roomName, room);
if (added)
{
return(room);
}
throw new SomeCustomException(Consts.PlanitPokerErrorConsts.SomeErrorWithRoomCreating);
}
public async Task <(bool sc, string oldConnectionId)> AddUserIntoRoom(Room room, PlanitUser user)
{
if (room == null)
{
throw new SomeCustomException(Consts.PlanitPokerErrorConsts.RoomNotFound);
}
if (string.IsNullOrWhiteSpace(user?.UserConnectionId) ||
string.IsNullOrWhiteSpace(user.Name))
{
throw new SomeCustomException(Consts.PlanitPokerErrorConsts.PlanitUserNotFound);
}
string oldConnectionId = null;
var success = await room.SetConcurentValueAsync <Room>(_multiThreadHelper, rm =>
{
var us = rm.StoredRoom.Users.FirstOrDefault(x => x.UserConnectionId == user.UserConnectionId ||
(user.MainAppUserId.HasValue &&
x.MainAppUserId == user.MainAppUserId));
if (us == null)
{
rm.StoredRoom.Users.Add(user);
}
else
{
us.Name = user.Name;
oldConnectionId = us.UserConnectionId;
us.UserConnectionId = user.UserConnectionId;
us.MainAppUserId ??= user.MainAppUserId;
}
return(Task.CompletedTask);
});
return(success, oldConnectionId);
//return true;
}
public async Task <(bool sc, string oldConnectionId)> AddUserIntoRoom(string roomName, PlanitUser user)
{
var room = await TryGetRoom(roomName);
return(await AddUserIntoRoom(room, user));
}
