public IPlanshetViewData Initial(IDbConnection connection, AllianceUserDataModel currentAllianceUser, IGameUserService profileService)
{
var userId = currentAllianceUser.UserId;
var allianceId = currentAllianceUser.AllianceId;
var allianses = GetAlliancesByRating(connection, i => i);
var allianceRattings = new List <IAllianceRatingOut>();
foreach (var i in allianses)
{
allianceRattings.Add(SetAllianceRating(connection, i, true, profileService));
}
var dataSerch = new TabAllianceSerchOut {
Collection = allianceRattings
};
dataSerch.AddAlianceButtons(allianceId);
var userAlliance = _getMyAllianceFromRattingTab(connection, dataSerch.Collection, userId, allianceId, profileService);
var role = AllianceRoleHelper.GetByRoleId(currentAllianceUser.RoleId);
userAlliance.AllianceTechesOut = GetAllianceTechesOut(connection, userAlliance.Id, role);
var manageAlliance = _getManageTab(connection, currentAllianceUser, role);
var tabs = AllianceOut.InitialTabs(dataSerch, userAlliance, manageAlliance, _localizer);
return(tabs);
}
/// <summary>
/// </summary>
/// <param name="rejectUserId"></param>
/// <exception cref="ArgumentNullException">Error.ConnectionUserNotExist</exception>
/// <exception cref="SecurityException">Error.NotPermitted</exception>
/// <exception cref="NotImplementedException">Error.UserNotHasHubGroup</exception>
/// <returns></returns>
public async Task <bool> RequestAllianceRejectRequestToAlliance(int rejectUserId)
{
return(await _contextActionAsync(async connection =>
{
var cr = _getLocalUser(Context.ConnectionId);
if (cr == null)
{
throw new ArgumentNullException(Error.ConnectionUserNotExist, nameof(cr));
}
var role = AllianceRoleHelper.GetByRoleId(cr.AllianceRoleId);
if (!role.AcceptNewMembers)
{
throw new SecurityException(Error.NotPermitted);
}
var groupName = cr.CreateAllianceRecrutManagerGroupName();
if (!cr.HasGroup(groupName))
{
throw new NotImplementedException(Error.UserNotHasHubGroup);
}
var curAu = _getAllianceUser(connection, cr);
var oldRequests = _allianceService.RejectRequestToAlliance(connection, curAu, rejectUserId, role);
var targetUser = _getOnlineSingleUser(connection, rejectUserId);
if (targetUser != null && targetUser.Connected && oldRequests != null && oldRequests.Count > 0)
{
var messageForUser = oldRequests.Last();
await Clients.Client(targetUser.ConnectionId).InvokeAsync("onRequestAllianceRejectRequestToAlliance",
rejectUserId, true, messageForUser);
}
await Clients.Group(groupName).InvokeAsync("onRequestAllianceRejectRequestToAlliance", rejectUserId);
return true;
}));
}
/// <summary>
/// </summary>
/// <param name="newDescription"></param>
/// <exception cref="ArgumentNullException">Error.ConnectionUserNotExist</exception>
/// <exception cref="ArgumentNullException">Error.ConnectionUserNotConnected</exception>
/// <returns></returns>
public async Task <object> AllianceInfoUpdateDescription(string newDescription)
{
return(await _contextActionAsync(async connection =>
{
if (newDescription.Length > (int)MaxLenghtConsts.AllianceDescription)
{
throw new ArgumentException(Error.OverMaxLength);
}
var cr = _getCurrentUser(connection);
var role = AllianceRoleHelper.GetByRoleId(cr.AllianceRoleId);
if (!role.EditAllianceInfo)
{
throw new SecurityException(Error.NotPermitted);
}
var newAllianceData = _allianceService.UpdateDescription(connection, cr.AllianceId, newDescription);
var aGroup = cr.CreateAllianceGroupName();
try
{
await Groups.RemoveFromGroupAsync(cr.ConnectionId, aGroup);
await Clients.Group(aGroup).InvokeAsync("onAllianceInfoUpdateDescription", newAllianceData.Description, cr.AllianceId);
}
finally
{
await Groups.AddToGroupAsync(cr.ConnectionId, aGroup);
}
return new { Id = cr.AllianceId, newAllianceData.Description };
}));
}
//todo при добавлении пользователя в альянс в channel_connection не добавляется новый пользователь
#region Common
public async Task <IPlanshetViewData> UserChannelsGetPlanshet()
{
return(await _contextAction(connection =>
{
var cr = _getCurrentUser(connection);
var aRole = AllianceRoleHelper.GetByRoleId(cr.AllianceRoleId);
// todo что то там сделать с ролями после получения планшента
return _channelService.InitialPlanshetChannels(connection, cr.UserId, cr.AllianceId, aRole);
}));
}
/// <summary>
/// </summary>
/// <param name="targetDropUserId"></param>
/// <exception cref="ArgumentNullException">Error.ConnectionUserNotExist</exception>
/// <exception cref="ArgumentNullException">Error.ConnectionUserNotConnected</exception>
/// <returns></returns>
public async Task <bool> AllianceDropUserFromAlliance(int targetDropUserId)
{
return(await _transactionAsync(async transaction =>
{
var connection = transaction.Connection;
var cr = _getCurrentUser(connection);
var role = AllianceRoleHelper.GetByRoleId(cr.AllianceRoleId);
if (!role.DeleteMembers)
{
throw new SecurityException(Error.NotPermitted);
}
var oldTargetAllianceUser = _allianceService.GetAllianceUserByUserId(connection, targetDropUserId);
var oldAllianceId = oldTargetAllianceUser.AllianceId;
var newTargetDropAllianceUser =
_allianceService.LeaveFromAlliance(connection, oldTargetAllianceUser, false);
//todo обработать чаты
ChannelConnectionDataModel newChannelConnectionDataModel = null;
ChannelDataModel newChannelDataModel = null;
var oldChannelId = 0;
_channelService.OnUserChangeAlliance(connection, oldAllianceId, newTargetDropAllianceUser,
(chtConn, channel) =>
{
newChannelConnectionDataModel = chtConn;
newChannelDataModel = channel;
}, oldChId => { oldChannelId = oldChId; });
var targetUser = _getOnlineSingleUser(connection, targetDropUserId);
if (targetUser != null)
{
await targetUser.RemoveAllianceGroupNameAsync(Groups);
targetUser.SetNewAllianceData(newTargetDropAllianceUser.Id, Npc.ConfederationName,
newTargetDropAllianceUser.RoleId, (byte)NpcAllianceId.Confederation);
var newGroupName = await targetUser.AddOrReplaceAllianceGroupAsync(Groups);
var updHubUser = _hubCache.AddOrUpdateLocal(targetUser, true);
// обновляем данные
var newTargetUserPlanshet =
_allianceSetNewPlanshetAndNotifyNewGroup(connection, updHubUser, newTargetDropAllianceUser, newGroupName);
var newAllianceChannelOutDataModel =
_channelService.GetAllianceChannelOut(connection, newChannelDataModel,
newChannelConnectionDataModel);
await Clients.Client(targetUser.ConnectionId).InvokeAsync("onAllianceUserDroped", cr.AllianceId,
updHubUser,
newTargetUserPlanshet, oldChannelId, newAllianceChannelOutDataModel);
}
var oldGroupName = cr.CreateAllianceGroupName();
_allianceNotifyOldAllianceUserLeft(targetDropUserId, cr.AllianceId, oldGroupName);
return true;
}));
}
private UserRequestModel _requestAllianceFromAllianceManageAddMessage(IDbConnection connection, AllianceMessageModelExt messageModel)
{
if (!messageModel.FromAlliance)
{
throw new NotImplementedException(nameof(messageModel.FromAlliance));
}
var curUserManager = _getLocalUser(Context.ConnectionId);
if (string.IsNullOrWhiteSpace(messageModel.Model.CreatorIcon))
{
throw new NotImplementedException(nameof(messageModel.Model.CreatorIcon));
}
if (messageModel.AllianceRoleId == 0 || messageModel.AllianceUserId == 0)
{
throw new InvalidOperationException(Error.NotPermitted);
}
if (curUserManager.AllianceId != messageModel.Model.FromId)
{
throw new SecurityException(Error.NotPermitted);
}
var role = AllianceRoleHelper.GetByRoleId(curUserManager.AllianceRoleId);
if (!role.AcceptNewMembers)
{
throw new SecurityException(Error.NotPermitted);
}
if (messageModel.Model.AllianceAccepted == 0)
{
messageModel.Model.AllianceAccepted = ArmAllianceAcceptedStatus.NoAction;
}
messageModel.Model.SourceType = MessageSourceType.IsAlliance;
messageModel.Model.DateCreate = UnixTime.UtcNow();
messageModel.Model = _allianceService.AddArmItem(connection, messageModel.Model);
var groupName = curUserManager.CreateAllianceRecrutManagerGroupName();
if (!curUserManager.HasGroup(groupName))
{
throw new NotImplementedException(Error.UserNotHasHubGroup);
}
return(new UserRequestModel
{
ConnectionUser = curUserManager,
MessageModel = messageModel,
GroupName = groupName
});
}
public IAllianceUserRequests GetAllianceUserRequests(IDbConnection connection, AllianceUserDataModel allianceUserManager, AllianceRoleDataModel role = null)
{
if (role == null)
{
role = AllianceRoleHelper.GetByRoleId(allianceUserManager.RoleId);
}
if (!role.AcceptNewMembers)
{
return(null);
}
var aur = new AllianceUserRequests(MessageSourceType.IsAlliance)
{
Requests = GetRequestsAllianceForAllianceManage(connection, allianceUserManager, role)
};
aur.SetComplexButtonView();
return(aur);
}
/// <summary>
/// </summary>
/// <param name="newBase64SourceImageModel"></param>
/// <exception cref="ArgumentNullException">Error.ConnectionUserNotExist</exception>
/// <exception cref="ArgumentNullException">Error.ConnectionUserNotConnected</exception>
/// <returns></returns>
public async Task <bool> AllianceInfoUpdateLabel(Base64ImageOut newBase64SourceImageModel)
{
return(await _contextActionAsync(async connection =>
{
var cr = _getCurrentUser(connection);
var role = AllianceRoleHelper.GetByRoleId(cr.AllianceRoleId);
if (!role.EditAllianceInfo)
{
throw new SecurityException(Error.NotPermitted);
}
var newUrls = await _allianceService.ImageServiceLoadAndUpdateAsync(connection,
newBase64SourceImageModel.Base64File, cr.AllianceId, _channelService,
newBase64SourceImageModel.Ext);
var aGroup = cr.CreateAllianceGroupName();
await Clients.Group(aGroup).InvokeAsync("onAllianceInfoUpdateLabel", newUrls, cr.AllianceId);
return true;
}));
}
/// <summary>
/// </summary>
/// <param name="newTax"></param>
/// <exception cref="ArgumentNullException">Error.ConnectionUserNotExist</exception>
/// <exception cref="ArgumentNullException">Error.ConnectionUserNotConnected</exception>
/// <returns></returns>
public async Task <bool> AllianceInfoUpdateTax(byte newTax)
{
return(await _contextActionAsync(async connection =>
{
var cr = _getCurrentUser(connection);
var role = AllianceRoleHelper.GetByRoleId(cr.AllianceRoleId);
if (!role.EditAllianceInfo)
{
throw new SecurityException(Error.NotPermitted);
}
if (newTax > 100)
{
newTax = 100;
}
var newAllianceData = _allianceService.UpdateTax(connection, cr.AllianceId, newTax);
var aGroup = cr.CreateAllianceGroupName();
await Clients.Group(aGroup).InvokeAsync("onAllianceInfoUpdateTax", newAllianceData.Tax, cr.AllianceId);
return true;
}));
}
public async Task <bool> AllianceUpdateAllianceTech(TechType allianceTechType)
{
return(await _contextActionAsync(async connection =>
{
var cr = _getCurrentUser(connection);
var role = AllianceRoleHelper.GetByRoleId(cr.AllianceRoleId);
if (!role.SetTech)
{
throw new SecurityException(Error.NotPermitted);
}
var newAllianceData = _allianceService.UpdateTech(connection, allianceTechType, cr.AllianceId);
var aGroup = cr.CreateAllianceGroupName();
await Clients.Group(aGroup).InvokeAsync("onAllianceTechUpdated", newAllianceData[OldNewAllianceKeys.NewTech],
newAllianceData[OldNewAllianceKeys.NewBalanceCc]);
return true;
}));
}
public static ChannelConnectionDataModel CreateModelByAllianceChannel(this ChannelDataModel allianceChannel, AllianceUserDataModel allianceUser)
{
return(allianceChannel.CreateModelByAllianceChannel(allianceUser, AllianceRoleHelper.GetByRoleId(allianceUser.RoleId)));
}
public AllianceRole(byte roleId)
{
SetRole(AllianceRoleHelper.GetByRoleId(roleId));
}
public void SetRole(string roleName)
{
SetRole(AllianceRoleHelper.GetByRoleName(roleName));
}
public async Task <bool> UserChannelsSendMessage(ChannelMessageTransfer messageModel)
{
_tryCatch(() => { messageModel.Validate(); });
return(await _contextActionAsync(async connection =>
{
var cr = _getCurrentUser(connection);
messageModel.DateCreate = UnixTime.UtcNow();
messageModel.UserId = cr.UserId;
messageModel.UserName = cr.Name;
//todo tmp
//========
var newMessage = _channelService.CreateMessage(connection, messageModel);
messageModel.UpdateByBase(newMessage);
//========
switch (messageModel.ChannelType)
{
case ChannelTypes.Private:
ConnectionUser targetUser = null;
PrivateChannelOut targetChannel = null;
var privateGroup = cr.CreatePrivateUserChannelGroupName(messageModel.ChannelId);
_channelService.ChekAndRestoreTargetPrivateChannel(connection, cr.UserId, newMessage.ChannelId,
targetUserId =>
{
targetUser = _getOnlineSingleUser(connection, targetUserId);
return targetUser != null;
}, targetChannelDataModel => { targetChannel = targetChannelDataModel; });
if (targetUser != null)
{
await Clients.Client(cr.ConnectionId).InvokeAsync("onUserChannelsSended", messageModel);
if (targetUser == null)
{
throw new NotImplementedException(nameof(targetUser));
}
if (targetChannel == null)
{
throw new NotImplementedException(nameof(targetChannel));
}
await targetUser.AddOrReplacePrivateChannelGroupNameAsync(Groups, targetChannel.ChannelId);
var updTuHubUser = _hubCache.AddOrUpdateLocal(targetUser, true);
var iHubGroupItem = updTuHubUser.GetUserChannelGroup(targetChannel.ChannelId);
await Clients.Client(updTuHubUser.ConnectionId)
.InvokeAsync("onUserChannelsCreatedPrivateChannel", targetChannel, iHubGroupItem);
}
else
{
await Clients.Group(privateGroup).InvokeAsync("onUserChannelsSended", messageModel);
}
return true;
case ChannelTypes.Group:
var groupChannelroup = cr.CreateGroupChannelGroupName(messageModel.ChannelId);
await Clients.Group(groupChannelroup).InvokeAsync("onUserChannelsSended", messageModel);
return true;
case ChannelTypes.Alliance:
var role = AllianceRoleHelper.GetByRoleId(cr.AllianceRoleId);
if (!role.MessageSend)
{
throw new SecurityException(Error.NotPermitted);
}
var allianceGroup = cr.CreateAllianceGroupName();
await Clients.Group(allianceGroup).InvokeAsync("onUserChannelsSended", messageModel);
return true;
default:
throw new ArgumentOutOfRangeException();
}
}));
}
/// <summary>
/// </summary>
/// <param name="messageModel"></param>
/// <exception cref="ArgumentNullException">Error.InputDataIncorrect</exception>
/// <exception cref="ArgumentNullException">Error.ConnectionUserNotExist</exception>
/// <exception cref="ArgumentNullException">Error.ConnectionUserNotConnected</exception>
/// <exception cref="SecurityException">Error.NotPermitted message alliance id is not equal</exception>
/// <exception cref="SecurityException">Error.NotPermitted not has role to manage</exception>
/// <exception cref="ArgumentException">target user Error.UserInAlliance</exception>
/// <returns></returns>
public async Task <AllianceMessageModelExt> RequestAllianceConfirmAcceptFromAllianceManage(
AllianceMessageModelExt messageModel)
{
_tryCatch(() =>
{
if (messageModel == null)
{
throw new ArgumentNullException(Error.InputDataIncorrect, nameof(messageModel));
}
if (messageModel.Model.ToId == 0)
{
throw new NotImplementedException(nameof(messageModel.Model.ToId));
}
});
return(await _contextActionAsync(async connection =>
{
var tergetAllianceUser = _allianceService.GetAllianceUserByUserId(connection, messageModel.Model.ToId);
if (tergetAllianceUser.AllianceId != (int)NpcAllianceId.Confederation)
{
var curUserManager = _getLocalUser(Context.ConnectionId);
if (messageModel.AllianceRoleId == 0 || messageModel.AllianceUserId == 0)
{
throw new InvalidOperationException(Error.NotPermitted);
}
if (curUserManager.AllianceId != messageModel.Model.FromId)
{
throw new SecurityException(Error.NotPermitted);
}
var role = AllianceRoleHelper.GetByRoleId(curUserManager.AllianceRoleId);
if (!role.AcceptNewMembers)
{
throw new SecurityException(Error.NotPermitted);
}
var crGroupName = curUserManager.CreateAllianceRecrutManagerGroupName();
if (!curUserManager.HasGroup(crGroupName))
{
throw new NotImplementedException(Error.UserNotHasHubGroup);
}
_allianceService.DeleteAllianceRequestsByManager(connection, curUserManager.AllianceId,
messageModel.Model.ToId, role.AcceptNewMembers);
var cid = curUserManager.ConnectionId;
try
{
await Groups.RemoveFromGroupAsync(cid, crGroupName);
await Clients.Group(crGroupName).InvokeAsync("onDeleteAllianceRequestsByManager",
curUserManager.AllianceId, messageModel.Model.ToId);
}
finally
{
await Groups.AddToGroupAsync(cid, crGroupName);
}
//todo проверить клиент почему тут исключение
throw new ArgumentException(Error.UserInAlliance);
}
messageModel.Model.AllianceAccepted = ArmAllianceAcceptedStatus.Accept;
messageModel.FromAlliance = true;
messageModel.Model.Message = "tr_ Confirmed";
var data = _requestAllianceFromAllianceManageAddMessage(connection, messageModel);
var targetUser = _getOnlineSingleUser(connection, data.MessageModel.Model.ToId);
if (targetUser != null && targetUser.Connected)
{
await Clients.Client(targetUser.ConnectionId)
.InvokeAsync("onRequestAllianceConfirmAcceptFromAllianceManage", data.MessageModel, true);
}
// Clients.Group(data.GroupName, data.ConnectionUser.ConnectionId)
await Clients.Group(data.GroupName)
.InvokeAsync("onRequestAllianceConfirmAcceptFromAllianceManage", data.MessageModel);
return data.MessageModel;
}));
}
public IList <AllianceRequestMessageDataModel> RejectRequestToAlliance(IDbConnection connection, AllianceUserDataModel currentUser, int rejectUserId, AllianceRoleDataModel role = null)
{
var permition = role ?? AllianceRoleHelper.GetByRoleId(currentUser.RoleId);
if (!permition.AcceptNewMembers)
{
throw new SecurityException(Error.NotPermitted);
}
var data = _armCache.LocalOperation(connection, col =>
{
return(col.Where(i =>
i.FromId == currentUser.AllianceId && i.ToId == rejectUserId &&
i.SourceType == MessageSourceType.IsAlliance ||
i.FromId == rejectUserId && i.ToId == currentUser.AllianceId &&
i.SourceType == MessageSourceType.IsUser).ToList());
});
if (!data.Any())
{
return(data);
}
foreach (var request in data)
{
request.AllianceAccepted = ArmAllianceAcceptedStatus.Reject;
}
var dbData = _armRepo.AddOrUpdateAllModels(connection, data);
var newData = _armCache.UpdateLocalItems(connection, dbData);
var alData = newData.FirstOrDefault(i => i.FromId == currentUser.AllianceId && i.SourceType == MessageSourceType.IsAlliance);
var rejectedUser = data.First(i => i.FromId == rejectUserId && i.SourceType == MessageSourceType.IsUser);
var armModel = new AllianceRequestMessageDataModel
{
AllianceAccepted = ArmAllianceAcceptedStatus.Reject,
ToId = rejectUserId,
DateCreate = UnixTime.UtcNow(),
FromId = currentUser.AllianceId,
Message = "Rejected",
UserAccepted = false,
SourceType = MessageSourceType.IsAlliance,
ToName = rejectedUser.FromName
};
armModel.AllianceAccepted = ArmAllianceAcceptedStatus.Reject;
if (alData == null)
{
var allaince = GetAllianceById(connection, currentUser.AllianceId, false);
if (allaince == null)
{
throw new NullReferenceException(Error.AllianceNotExist);
}
armModel.FromName = allaince.Name;
armModel.CreatorIcon = allaince.Images.Icon;
}
else
{
armModel.FromName = alData.FromName;
armModel.CreatorIcon = alData.CreatorIcon;
}
var messageForUser = AddArmItem(connection, armModel);
newData.Add(messageForUser);
return(newData);
}
private async Task <Dictionary <string, object> > _initUserAsync(IDbConnection connection, string curInitConnectionUserId, LangKeys langKey)
{
try
{
var user = _getPrincipalUser();
//todo поставил заглушку, сейчас можно извлеч имя или обращатсья в базу
var authId = user.GetAuthUserId();
var oldUserConnections = _getLocalUserListByAuthId(connection, authId);
if (oldUserConnections != null && oldUserConnections.Any())
{
foreach (var conItem in oldUserConnections)
{
var cId = conItem.ConnectionId;
var uId = conItem.UserId;
_removeUserFromStorage(cId);
await conItem.RemoveUserFromAllHubGroups(Groups);
_gameRunner.OnDisonnected(cId, uId);
await Clients.Client(conItem.ConnectionId).InvokeAsync("disconnect", true);
}
}
var data = _estateOwnService.InitUser(connection, user, _svp);
var cr = (ConnectionUser)data[ConnectionUser.ViewKey];
if (cr == null)
{
throw new NotImplementedException("MainGameHub.UnitUser");
}
cr.Lang = langKey;
cr.ConnectionId = curInitConnectionUserId;
var addGroupsTasks = new List <Task> {
cr.AddOrReplaceAllianceGroupAsync(Groups)
};
var userAllianceRole = AllianceRoleHelper.GetByRoleId(cr.AllianceRoleId);
if (cr.AllianceId != (byte)NpcAllianceId.Confederation)
{
if (userAllianceRole.AcceptNewMembers)
{
addGroupsTasks.Add(cr.AddOrReplaceAllianceRecrutManagerGroupAsync(Groups));
}
}
var messages = _channelService.InitialPlanshetChannels(connection, cr.UserId, cr.AllianceId, userAllianceRole);
var privateChannesData = messages.Bodys[0].TemplateData as ChannelTab;
if (privateChannesData != null && privateChannesData.Collection.Any())
{
addGroupsTasks.AddRange(privateChannesData.Collection.Select(privateChannesl =>
cr.AddOrReplacePrivateChannelGroupNameAsync(Groups, privateChannesl.Key)));
}
var groupChannesData = messages.Bodys[1].TemplateData as ChannelTab;
if (groupChannesData != null && groupChannesData.Collection.Any())
{
addGroupsTasks.AddRange(groupChannesData.Collection.Select(groupChannel =>
cr.AddOrReplaceGroupChannelGroupNameAsync(Groups, groupChannel.Key,
groupChannel.Value.ChannelName)));
}
await Task.WhenAll(addGroupsTasks);
data[messages.UniqueId] = messages;
data[ConnectionUser.ViewKey] = _hubCache.AddOrUpdateLocal(cr, true);
var confederationPlanshet = _confederationService.InitialPlanshetConfederation(connection, _gameUserService);
data[confederationPlanshet.UniqueId] = confederationPlanshet;
var estates = (IList <EstateItemOut>)data[EstateItemOut.ViewKey];
var planetIds = estates.Where(i => i.OwnId != 0).Select(i => i.OwnId).ToList();
var journalPlanshet = _journalOutService.InitialPlanshet(connection, cr.UserId, planetIds);
data[journalPlanshet.UniqueId] = journalPlanshet;
return(data);
}
catch (Exception e)
{
throw new HubException(e.Message, e);
}
}
public IList <AllianceUserRequestItem> GetRequestsAllianceForAllianceManage(IDbConnection connection, AllianceUserDataModel allianceUserManager, AllianceRoleDataModel role = null)
{
var permition = role ?? AllianceRoleHelper.GetByRoleId(allianceUserManager.RoleId);
if (!permition.AcceptNewMembers)
{
throw new SecurityException(Error.NotPermitted);
}
var data = _armCache.LocalOperation(connection, col =>
{
var collection = col.Where(i => i.AllianceAccepted != ArmAllianceAcceptedStatus.Reject &&
(i.FromId == allianceUserManager.AllianceId &&
i.SourceType == MessageSourceType.IsAlliance ||
i.ToId == allianceUserManager.AllianceId &&
i.SourceType == MessageSourceType.IsUser))
.OrderByDescending(i => i.DateCreate)
.ToList();
return(collection);
});
var usersGroups = new Dictionary <int, List <AllianceRequestMessageDataModel> >();
foreach (var request in data)
{
if (!usersGroups.ContainsKey(request.ToId) && request.SourceType == MessageSourceType.IsAlliance ||
!usersGroups.ContainsKey(request.FromId) && request.SourceType == MessageSourceType.IsUser)
{
usersGroups.Add(request.SourceType == MessageSourceType.IsAlliance ? request.ToId : request.FromId,
new List <AllianceRequestMessageDataModel> {
request
});
}
else
{
usersGroups[request.SourceType == MessageSourceType.IsAlliance ? request.ToId : request.FromId]
.Add(request);
}
}
var result = usersGroups.Select(group =>
{
var allianceAccepted = ArmAllianceAcceptedStatus.NoAction;
if (group.Value.Any(i => i.AllianceAccepted == ArmAllianceAcceptedStatus.Accept))
{
allianceAccepted = ArmAllianceAcceptedStatus.Accept;
}
var userAccepted = group.Value.Any(i => i.UserAccepted);
var groupName = group.Value.First(i => i.SourceType == MessageSourceType.IsUser).FromName;
return(new AllianceUserRequestItem
{
GroupName = groupName,
GroupId = group.Key,
Messages = group.Value.OrderBy(i => i.DateCreate).ToList(),
AllianceAccepted = allianceAccepted,
UserAccepted = userAccepted
});
}).ToList();
return(result);
}
/// <summary>
/// </summary>
/// <param name="targetAllianceUserId"></param>
/// <param name="targetUserId"></param>
/// <param name="targetRoleId"></param>
/// <exception cref="ArgumentNullException">Error.ConnectionUserNotExist</exception>
/// <exception cref="ArgumentNullException">Error.ConnectionUserNotConnected</exception>
/// <returns></returns>
public async Task <object> AllianceUpdateUserRole(int targetAllianceUserId, int targetUserId, byte targetRoleId)
{
return(await _contextActionAsync(async connection =>
{
var cr = _getCurrentUser(connection);
var curUserManagerRole = AllianceRoleHelper.GetByRoleId(cr.AllianceRoleId);
if (!curUserManagerRole.CanManagePermition)
{
throw new SecurityException(Error.NotPermitted);
}
var newTarAu = _allianceService.UpdateUserRole(connection, cr.UserId, cr.AllianceId, targetUserId, targetRoleId,
targetAllianceUserId);
var targetUser = _getOnlineSingleUser(connection, newTarAu.UserId);
var aGroup = cr.CreateAllianceGroupName();
var exIds = new List <string>();
var newTargetUserRole = AllianceRoleHelper.GetByRoleId(targetRoleId);
var updateUserRoleModel =
new UpdateUserRoleModel(newTarAu.AllianceId, newTarAu.UserId, newTargetUserRole);
if (targetUser != null)
{
exIds.Add(targetUser.ConnectionId);
var oldTargetUserRole = AllianceRoleHelper.GetByRoleId(targetUser.AllianceRoleId);
await targetUser.UpdateAllianceGroupsByPermitionsAsync(Groups, oldTargetUserRole,
newTargetUserRole);
targetUser.AllianceRoleId = newTargetUserRole.Id;
var updatedTargetUser = _hubCache.AddOrUpdateLocal(targetUser, false);
updateUserRoleModel.SetUserData(connection, _allianceService, newTarAu, updatedTargetUser);
await Clients.Client(targetUser.ConnectionId).InvokeAsync("onAllianceUpdateUserRole", updateUserRoleModel.GetUserModel());
}
// todo не доделано не верный формат возвращемых данныъ
var allianceResponceModel = updateUserRoleModel.GetAllianceModel();
try
{
foreach (var exceptedId in exIds)
{
await Groups.RemoveFromGroupAsync(exceptedId, aGroup);
}
await Clients.Group(aGroup).InvokeAsync("onAllianceUpdateUserRole", allianceResponceModel);
}
finally
{
foreach (var exceptedId in exIds)
{
await Groups.AddToGroupAsync(exceptedId, aGroup);
}
}
return allianceResponceModel;
}));
}
public bool HasRoleToManageMessage(IDbConnection connection, AllianceUserDataModel currentUser, int outAllianceUserId)
{
return(currentUser.Id == outAllianceUserId &&
AllianceRoleHelper.GetByRoleId(currentUser.RoleId).AcceptNewMembers);
}
private void _onUserChangeAlliance(IDbConnection connection, int oldAllianceId, AllianceUserDataModel newAllianceUserDataModel, Action <ChannelConnectionDataModel, ChannelDataModel> setNewChannelData, Action <int> setOldChannelId)
{
var typeChannel = (byte)ChannelTypes.Alliance;
ChannelConnectionDataModel newChannelConnectionDataModel = null;
ChannelDataModel newChannelDataModel = null;
var channels = _channelRepo.GetChannels(connection, new List <int> {
oldAllianceId, newAllianceUserDataModel.AllianceId
}, typeChannel);
if (!channels.Any())
{
throw new NotImplementedException("!channels.Any()");
}
//var channels = c.channel.Where(i =>
// i.creatorId == oldAllianceId || i.creatorId == newAllianceUserDataModel.AllianceId &&
// i.channelType == typeChannel).ToList();
var oldChannel = channels.First(i => i.creatorId == oldAllianceId);
var newChannel = channels.First(i => i.creatorId == newAllianceUserDataModel.AllianceId);
setOldChannelId(oldChannel.Id);
var oldConnection = _channelConnRepo.GetUserConnectedChannl(connection, oldChannel.Id, newAllianceUserDataModel.UserId, typeChannel);
newChannelDataModel = newChannel.ConvertToWorkModel();
var newRole = AllianceRoleHelper.GetByRoleId(newAllianceUserDataModel.RoleId);
if (oldConnection != null)
{
oldConnection.password = newChannel.password;
oldConnection.channelId = newChannel.Id;
oldConnection.messageRead = newRole.MessageRead;
oldConnection.messageSend = newRole.MessageSend;
var updOldConnection = _channelConnRepo.Update(connection, oldConnection);
if (!updOldConnection)
{
throw new NotImplementedException();
}
newChannelConnectionDataModel = _channelConnRepo.ConvertToWorkModel(oldConnection);
}
else
{
var data = _channelConnRepo.AddOrUpdate(connection, new channel_connection
{
userId = newAllianceUserDataModel.UserId,
messageRead = newRole.MessageRead,
messageSend = newRole.MessageSend,
password = newChannel.password,
channelType = newChannel.channelType,
channelId = newChannel.Id
});
newChannelConnectionDataModel = _channelConnRepo.ConvertToWorkModel(data);
setNewChannelData(newChannelConnectionDataModel, newChannelDataModel);
}
if (newChannelDataModel.ChannelConnections == null)
{
newChannelDataModel.ChannelConnections = new List <ChannelConnectionDataModel> {
newChannelConnectionDataModel
};
}
else
{
newChannelDataModel.ChannelConnections.Add(newChannelConnectionDataModel);
}
setNewChannelData(newChannelConnectionDataModel, newChannelDataModel);
}
