public LoginRequestHandlerTests()
{
var fixture = new Fixture();
fixture.Behaviors.Add(new OmitOnRecursionBehavior());
_commandDispatcher = new Mock <ICommandDispatcher>();
_queryDispatcher = new Mock <IQueryDispatcher>();
_signInManager = GetMockSignInManager();
_testLoginRequest = fixture.Create <LoginRequest>();
_testUser = fixture.Create <ApplicationUser>();
_tokenService = new Mock <ITokenService>();
_queryDispatcher
.Setup(x => x.Dispatch <UserGetByUsernameQuery, ApplicationUser>(It.IsNotNull <UserGetByUsernameQuery>()))
.ReturnsAsync(_testUser);
_signInManager
.Setup(x => x.PasswordSignInAsync(It.IsNotNull <string>(), It.IsNotNull <string>(), true, false))
.ReturnsAsync(SignInResult.Success);
_tokenService
.Setup(x => x.GenerateAccessToken(It.Is <ApplicationUser>(u => u != null)))
.Returns("token");
_tokenService
.Setup(x => x.GenerateRefreshToken(It.Is <ApplicationUser>(u => u != null)))
.Returns(fixture.Create <RefreshTokenRecord>());
_handler = new LoginRequestHandler(
_commandDispatcher.Object,
_queryDispatcher.Object,
_signInManager.Object,
_tokenService.Object);
}
private void PasswordCheckCallback(GamePlayer player, byte response)
{
if (response != 0x01)
{
return;
}
var newPassword = player.TempProperties.getProperty <string>(this, null);
if (newPassword == null)
{
return;
}
player.TempProperties.removeProperty(this);
player.Out.SendMessage("Your password has been changed.", eChatType.CT_Important, eChatLoc.CL_SystemWindow);
player.Client.Account.Password = LoginRequestHandler.CryptPassword(newPassword);
GameServer.Database.SaveObject(player.Client.Account);
// Log change
AuditMgr.AddAuditEntry(player, AuditType.Account, AuditSubtype.AccountPasswordChange, "", player.Name);
if (log.IsInfoEnabled)
{
log.Info(player.Name + " (" + player.Client.Account.Name + ") changed password.");
}
}
public async Task Should_Have_Return_Token()
{
var handler = new LoginRequestHandler(authenticationService, userRepository);
var result = await handler.Handle(new LoginRequest()
{
UserName = "******", Password = "******"
}, CancellationToken.None);
Assert.IsType <TokenResponseModel>(result);
Assert.NotNull(result);
}
public async void InvalidLogin()
{
LoginRequest request = new LoginRequest()
{
Login = new Login()
{
UserName = "******", Password = "******"
}
};
LoginRequestHandler handler = new LoginRequestHandler(tokenService, fakeUserManager.Object, context.Object);
var response = await handler.Handle(request, new CancellationToken());
Assert.NotNull(response.Error);
}
public async void ValidLoginForCustomer()
{
fakeUserManager.Setup(x => x.IsInRoleAsync(It.IsAny <ApplicationUser>(), "Administrator"))
.Returns(Task.FromResult <bool>(false));
fakeUserManager.Setup(x => x.CheckPasswordAsync(It.IsAny <ApplicationUser>(), It.IsAny <string>()))
.Returns(Task.FromResult <bool>(true));
LoginRequest request = new LoginRequest()
{
Login = new Login()
{
UserName = "******", Password = "******"
}
};
LoginRequestHandler handler = new LoginRequestHandler(tokenService, fakeUserManager.Object, context.Object);
var response = await handler.Handle(request, new CancellationToken());
Assert.Equal("Test", response.UserName);
Assert.False(response.IsAdmin);
}
/// <summary>
/// Validate a User against database and init its GUID.
/// </summary>
/// <param name="username"></param>
/// <param name="password"></param>
/// <param name="errormessage"></param>
/// <returns></returns>
public static bool ValidateUser(string username, string password, out Guid guid, out string errormessage)
{
guid = Guid.NewGuid();
// Validate Fields
if (string.IsNullOrEmpty(username) || string.IsNullOrEmpty(password))
{
errormessage = "Empty Username or Password...";
return(false);
}
// Try to find the player
Account playerAccount = null;
try
{
playerAccount = GameServer.Database.FindObjectByKey <Account>(username);
}
catch
{
errormessage = "Error while querying Database !";
return(false);
}
// Validate account
if (playerAccount != null && playerAccount.Password.Equals(LoginRequestHandler.CryptPassword(password)))
{
// Success
DOLUserMapper.AddAuthenticatedUser(guid, new DOLUserIdentity(playerAccount, guid));
errormessage = string.Empty;
return(true);
}
else
{
errormessage = "Wrong Login or Password !";
}
return(false);
}
public void AddAndInitPlayer(Player player, bool sendSettings = false)
{
var petActivated = player.Pet != null && player.Pet.Activated;
if (petActivated)
{
player.Pet.Deactivate(true);
}
LoginRequestHandler.SendPlayer(player);
AddCharacter(player);
if (petActivated)
{
player.Pet.Activate();
}
if (sendSettings)
{
LoginRequestHandler.SendSettings(player);
}
}
public void OnCommand(GameClient client, string[] args)
{
string usage = "Usage: /password <current_password> <new_password>";
if (args.Length < 3)
{
client.Out.SendMessage(usage, eChatType.CT_System, eChatLoc.CL_SystemWindow);
return;
}
try
{
string oldPassword = args[1];
string newPassword = args[2];
if ((client.Account != null) && (LoginRequestHandler.CryptPassword(oldPassword) == client.Account.Password))
{
// TODO: Add confirmation dialog
// TODO: If user has set their email address, mail them the change notification
client.Player.TempProperties.setProperty(this, newPassword);
client.Out.SendCustomDialog("Do you wish to change your password to \n" + newPassword, PasswordCheckCallback);
}
else
{
client.Out.SendMessage("Your current password was incorrect.", eChatType.CT_Important, eChatLoc.CL_SystemWindow);
if (log.IsInfoEnabled)
{
log.Info(client.Player.Name + " (" + client.Account.Name + ") attempted to change password but failed!");
}
return;
}
}
catch (Exception)
{
client.Out.SendMessage(usage, eChatType.CT_System, eChatLoc.CL_SystemWindow);
}
}
public void OnCommand(GameClient client, string[] args)
{
if (args.Length < 2)
{
DisplaySyntax(client);
return;
}
switch (args[1].ToLower())
{
#region Create
case "create":
{
if (args.Length < 4)
{
DisplaySyntax(client);
return;
}
string AccountName = args[2].ToLower();
string Password = args[3];
foreach (char c in AccountName.ToCharArray())
{
if ((c < '0' || c > '9') && (c < 'a' || c > 'z'))
{
DisplayMessage(client, LanguageMgr.GetTranslation(client.Account.Language, "AdminCommands.Account.InvalidAccountName"));
return;
}
}
if (AccountName.Length < 4 || Password.Length < 4)
{
DisplayMessage(client, LanguageMgr.GetTranslation(client.Account.Language, "AdminCommands.Account.InvalidAccountNameOrPassword"));
return;
}
Account account = GetAccount(AccountName);
if (account != null)
{
DisplayMessage(client, LanguageMgr.GetTranslation(client.Account.Language, "AdminCommands.Account.AccountNameAlreadyRegistered"));
return;
}
account = new Account();
account.Name = AccountName;
account.Password = PacketHandler.Client.v168.LoginRequestHandler.CryptPassword(Password);
account.PrivLevel = (uint)ePrivLevel.Player;
account.Realm = (int)eRealm.None;
account.CreationDate = DateTime.Now;
account.Language = ServerProperties.Properties.SERV_LANGUAGE;
GameServer.Database.AddObject(account);
DisplayMessage(client, LanguageMgr.GetTranslation(client.Account.Language, "AdminCommands.Account.AccountCreated"));
}
break;
#endregion Create
#region ChangePassword
case "changepassword":
{
if (args.Length < 4)
{
DisplaySyntax(client);
return;
}
string accountname = args[2];
string newpass = args[3];
Account acc = GetAccount(accountname);
if (acc == null)
{
DisplayMessage(client, LanguageMgr.GetTranslation(client.Account.Language, "AdminCommands.Account.AccountNotFound", accountname));
return;
}
acc.Password = LoginRequestHandler.CryptPassword(newpass);
GameServer.Database.SaveObject(acc);
// Log change
AuditMgr.AddAuditEntry(client, AuditType.Account, AuditSubtype.AccountPasswordChange, "", (client.Player != null ? client.Player.Name : ""));
}
break;
#endregion ChangePassword
#region Delete
case "delete":
{
if (args.Length < 3)
{
DisplaySyntax(client);
return;
}
string AccountName = args[2];
Account acc = GetAccount(AccountName);
if (acc == null)
{
DisplayMessage(client, LanguageMgr.GetTranslation(client.Account.Language, "AdminCommands.Account.AccountNotFound", AccountName));
return;
}
KickAccount(acc);
GameServer.Database.DeleteObject(acc);
// Log change
AuditMgr.AddAuditEntry(client, AuditType.Account, AuditSubtype.AccountDelete, "acct=" + AccountName, (client.Player != null ? client.Player.Name : ""));
DisplayMessage(client, LanguageMgr.GetTranslation(client.Account.Language, "AdminCommands.Account.AccountDeleted", acc.Name));
return;
}
#endregion Delete
#region DeleteCharacter
case "deletecharacter":
{
if (args.Length < 3)
{
DisplaySyntax(client);
return;
}
string charname = args[2];
DOLCharacters cha = GetCharacter(charname);
if (cha == null)
{
DisplayMessage(client, LanguageMgr.GetTranslation(client.Account.Language, "AdminCommands.Account.CharacterNotFound", charname));
return;
}
KickCharacter(cha);
GameServer.Database.DeleteObject(cha);
// Log change
AuditMgr.AddAuditEntry(client, AuditType.Character, AuditSubtype.CharacterDelete, "char=" + charname, (client.Player != null ? client.Player.Name : ""));
DisplayMessage(client, LanguageMgr.GetTranslation(client.Account.Language, "AdminCommands.Account.CharacterDeleted", cha.Name));
return;
}
#endregion DeleteCharacter
#region MoveCharacter
case "movecharacter":
{
if (args.Length < 4)
{
DisplaySyntax(client);
return;
}
string charname = args[2];
string accountname = args[3];
DOLCharacters cha = GetCharacter(charname);
if (cha == null)
{
DisplayMessage(client, LanguageMgr.GetTranslation(client.Account.Language, "AdminCommands.Account.CharacterNotFound", charname));
return;
}
Account acc = GetAccount(accountname);
if (acc == null)
{
DisplayMessage(client, LanguageMgr.GetTranslation(client.Account.Language, "AdminCommands.Account.AccountNotFound", accountname));
return;
}
int firstAccountSlot = 0;
switch ((eRealm)cha.Realm)
{
case eRealm.Albion:
firstAccountSlot = 1 * 8;
break;
case eRealm.Midgard:
firstAccountSlot = 2 * 8;
break;
case eRealm.Hibernia:
firstAccountSlot = 3 * 8;
break;
default:
DisplayMessage(client, LanguageMgr.GetTranslation(client.Account.Language, "AdminCommands.Account.CharNotFromValidRealm"));
return;
}
int freeslot = 0;
for (freeslot = firstAccountSlot; freeslot < firstAccountSlot + 8; freeslot++)
{
bool found = false;
foreach (DOLCharacters ch in acc.Characters)
{
if (ch.Realm == cha.Realm && ch.AccountSlot == freeslot)
{
found = true;
break;
}
}
if (!found)
{
break;
}
}
if (freeslot == 0)
{
DisplayMessage(client, LanguageMgr.GetTranslation(client.Account.Language, "AdminCommands.Account.AccountHasNoFreeSlots", accountname));
return;
}
GameClient playingclient = WorldMgr.GetClientByPlayerName(cha.Name, true, false);
if (playingclient != null)
{
playingclient.Out.SendPlayerQuit(true);
playingclient.Disconnect();
}
cha.AccountName = acc.Name;
cha.AccountSlot = freeslot;
GameServer.Database.SaveObject(cha);
DisplayMessage(client, LanguageMgr.GetTranslation(client.Account.Language, "AdminCommands.Account.CharacterMovedToAccount", cha.Name, acc.Name));
return;
}
#endregion MoveCharacter
#region Status
case "status":
{
if (args.Length < 4)
{
DisplaySyntax(client);
return;
}
string accountname = args[2];
Account acc = GetAccount(accountname);
if (acc == null)
{
DisplayMessage(client, LanguageMgr.GetTranslation(client.Account.Language, "AdminCommands.Account.AccountNotFound", accountname));
return;
}
int status = -1;
try { status = Convert.ToInt32(args[3]); } catch (Exception) { DisplaySyntax(client); return; }
if (status >= 0 && status < 256)
{
acc.Status = status;
GameServer.Database.SaveObject(acc);
DisplayMessage(client, "Account " + acc.Name + " Status is now set to : " + acc.Status);
}
else
{
DisplaySyntax(client);
}
return;
}
#endregion Status
#region Unban
case "unban":
{
if (args.Length < 3)
{
DisplaySyntax(client);
return;
}
string accountname = args[2];
Account acc = GetAccount(accountname);
if (acc == null)
{
DisplayMessage(client, LanguageMgr.GetTranslation(client.Account.Language, "AdminCommands.Account.AccountNotFound", accountname));
return;
}
var banacc = GameServer.Database.SelectObjects <DBBannedAccount>("(`Type` = @TypeA OR `Type` = @TypeB) AND `Account` = @Account", new[] { new QueryParameter("@TypeA", "A"), new QueryParameter("@TypeB", "B"), new QueryParameter("@Account", accountname) });
if (banacc.Count == 0)
{
DisplayMessage(client, LanguageMgr.GetTranslation(client.Account.Language, "AdminCommands.Account.AccountNotFound", accountname));
return;
}
try
{
GameServer.Database.DeleteObject(banacc);
}
catch (Exception) { DisplaySyntax(client); return; }
DisplayMessage(client, "Account " + accountname + " unbanned!");
return;
}
#endregion Unban
#region AccountName
case "accountname":
{
if (args.Length < 3)
{
DisplaySyntax(client);
return;
}
string CharName = args[2];
DOLCharacters Char = GetCharacter(CharName);
if (Char == null)
{
DisplayMessage(client, LanguageMgr.GetTranslation(client.Account.Language, "AdminCommands.Account.CharacterNotFound", CharName));
return;
}
string AccName = GetAccountName(Char.Name);
DisplayMessage(client, LanguageMgr.GetTranslation(client.Account.Language, "AdminCommands.Account.AccNameForChar", Char.Name, AccName));
return;
}
#endregion AccountName
}
}
public async Task SendMessageAsync(Message msg)
{
await _networkCommunication.SendBytesAsync(new[] { (byte)msg.Type });
await _networkCommunication.SendShortAsync((short)msg.Id);
switch (msg)
{
// Error
case ErrorResponse errorResponse:
var errorResponseHandler = new ErrorResponseHandler(_networkCommunication);
await errorResponseHandler.SendMessageAsync(errorResponse);
break;
// Login
case LoginRequest loginRequest:
var loginRequestHandler = new LoginRequestHandler(_networkCommunication);
await loginRequestHandler.SendMessageAsync(loginRequest);
break;
case LoginResponse loginResponse:
var loginResponseHandler = new LoginResponseHandler(_networkCommunication);
await loginResponseHandler.SendMessageAsync(loginResponse);
break;
// Create User
case CreateUserRequest createUserRequest:
var createUserRequestHandler = new CreateUserRequestHandler(_networkCommunication);
await createUserRequestHandler.SendMessageAsync(createUserRequest);
break;
case CreateUserResponse createUserResponse:
var createUserResponseHandler = new CreateUserResponseHandler(_networkCommunication);
await createUserResponseHandler.SendMessageAsync(createUserResponse);
break;
// Create photo
case CreatePhotoRequest createPhotoRequest:
var createPhotoRequestHandler = new CreatePhotoRequestHandler(
_networkCommunication,
_fileCommunication
);
await createPhotoRequestHandler.SendMessageAsync(createPhotoRequest);
break;
case CreatePhotoResponse createPhotoResponse:
var createPhotoResponseHandler = new CreatePhotoResponseHandler();
await createPhotoResponseHandler.SendMessageAsync(createPhotoResponse);
break;
// Photo list
case PhotoListRequest photoListRequest:
var photoListRequestHandler = new PhotoListRequestHandler(_networkCommunication);
await photoListRequestHandler.SendMessageAsync(photoListRequest);
break;
case PhotoListResponse photoListResponse:
var photoListResponseHandler = new PhotoListResponseHandler(
_networkCommunication,
_fileCommunication
);
await photoListResponseHandler.SendMessageAsync(photoListResponse);
break;
// User list
case UserListRequest userListRequest:
var userListRequestHandler = new UserListRequestHandler();
await userListRequestHandler.SendMessageAsync(userListRequest);
break;
case UserListResponse userListResponse:
var userListResponseHandler = new UserListResponseHandler(
_networkCommunication
);
await userListResponseHandler.SendMessageAsync(userListResponse);
break;
// Comment photo
case CommentPhotoRequest commentPhotoRequest:
var commentPhotoRequestHandler = new CommentPhotoRequestHandler(_networkCommunication);
await commentPhotoRequestHandler.SendMessageAsync(commentPhotoRequest);
break;
case CommentPhotoResponse commentPhotoResponse:
var commentPhotoResponseHandler = new CommentPhotoResponseHandler(
_networkCommunication
);
await commentPhotoResponseHandler.SendMessageAsync(commentPhotoResponse);
break;
// Comment List
case CommentListRequest commentListRequest:
var commentListRequestHandler = new CommentListRequestHandler(_networkCommunication);
await commentListRequestHandler.SendMessageAsync(commentListRequest);
break;
case CommentListResponse commentListResponse:
var commentListResponseHandler = new CommentListResponseHandler(
_networkCommunication
);
await commentListResponseHandler.SendMessageAsync(commentListResponse);
break;
// Logout
case LogoutRequest logoutRequest:
var logoutRequestHandler = new LogoutRequestHandler();
await logoutRequestHandler.SendMessageAsync(logoutRequest);
break;
case LogoutResponse logoutResponse:
var logoutResponseHandler = new LogoutResponseHandler();
await logoutResponseHandler.SendMessageAsync(logoutResponse);
break;
default:
// TODO Create a custom exception
throw new Exception($"Message not recognized ID={msg.Id}, type={msg.Type}");
}
}
public static IRequestHandler InitRequestHandler(
Request request,
ClientConnection clientConnection,
ClientRequestService clientRequestService,
IAppServiceProvider appServiceProvider)
{
IRequestHandler requestHandler;
switch (request.RequestType)
{
case RequestType.VerificationUser:
{
requestHandler = new VerificationUserRequestHandler(
request,
clientConnection,
appServiceProvider.LoadUsersService,
appServiceProvider.UpdateUsersService,
appServiceProvider.VerificationCodesService,
appServiceProvider.SmsService);
}
break;
case RequestType.NewUser:
{
requestHandler = new NewUserRequestHandler(
request,
clientConnection,
appServiceProvider.NodeNoticeService,
appServiceProvider.CreateUsersService,
appServiceProvider.TokensService,
appServiceProvider.VerificationCodesService,
appServiceProvider.LoadUsersService);
}
break;
case RequestType.Login:
{
requestHandler = new LoginRequestHandler(
request,
clientConnection,
appServiceProvider.ConnectionsService,
appServiceProvider.NoticeService,
appServiceProvider.TokensService,
appServiceProvider.LoadUsersService,
appServiceProvider.PendingMessagesService,
appServiceProvider.NodeRequestSender);
}
break;
case RequestType.GetMessages:
{
requestHandler = new GetMessagesRequestHandler(
request,
clientConnection,
appServiceProvider.ConnectionsService,
appServiceProvider.LoadMessagesService,
appServiceProvider.CreateMessagesService,
appServiceProvider.AttachmentsService,
appServiceProvider.LoadChatsService,
appServiceProvider.ConversationsService,
appServiceProvider.NodeRequestSender);
}
break;
case RequestType.Logout:
{
requestHandler = new LogoutRequestHandler(request, clientConnection, appServiceProvider.ConnectionsService, appServiceProvider.TokensService);
}
break;
case RequestType.SendMessages:
{
requestHandler = new SendMessagesRequestHandler(
request,
clientConnection,
appServiceProvider.NodeNoticeService,
appServiceProvider.ConversationsNoticeService,
appServiceProvider.AttachmentsService,
appServiceProvider.CreateMessagesService,
appServiceProvider.LoadDialogsService);
}
break;
case RequestType.NewChats:
{
requestHandler = new NewChatRequestHandler(
request,
clientConnection,
appServiceProvider.NodeNoticeService,
appServiceProvider.ConversationsNoticeService,
appServiceProvider.CreateChatsService);
}
break;
case RequestType.EditUser:
{
requestHandler = new EditUserRequestHandler(request, clientConnection, appServiceProvider.NodeNoticeService, appServiceProvider.UpdateUsersService);
}
break;
case RequestType.DeleteConversation:
{
requestHandler = new DeleteConversationsRequestHandler(
request,
clientConnection,
appServiceProvider.NodeNoticeService,
appServiceProvider.LoadChatsService,
appServiceProvider.DeleteChatsService,
appServiceProvider.LoadDialogsService,
appServiceProvider.DeleteDialogsService,
appServiceProvider.LoadChannelsService,
appServiceProvider.DeleteChannelsService);
}
break;
case RequestType.RefreshTokens:
{
requestHandler = new RefreshTokensRequestHandler(request, clientConnection, appServiceProvider.TokensService);
}
break;
case RequestType.DownloadFile:
{
throw new WebSocketNotSupportException();
}
case RequestType.GetUserFilesInformation:
{
requestHandler = new GetUserFilesRequestHandler(request, clientConnection, appServiceProvider.FilesService);
}
break;
case RequestType.GetInformationNode:
{
requestHandler = new GetInformationNodeRequestHandler(request, appServiceProvider.NodesService);
}
break;
case RequestType.EditChats:
{
requestHandler = new EditChatsRequestHandler(
request,
clientConnection,
appServiceProvider.NodeNoticeService,
appServiceProvider.ConversationsNoticeService,
appServiceProvider.UpdateChatsService,
appServiceProvider.LoadChatsService,
appServiceProvider.SystemMessagesService);
}
break;
case RequestType.UploadFile:
{
throw new WebSocketNotSupportException();
}
case RequestType.AddUsersChats:
{
requestHandler = new AddUserChatsRequestHandler(
request,
clientConnection,
appServiceProvider.NodeNoticeService,
appServiceProvider.ConversationsNoticeService,
appServiceProvider.UpdateChatsService,
appServiceProvider.LoadChatsService,
appServiceProvider.NodeRequestSender,
appServiceProvider.ConnectionsService,
appServiceProvider.SystemMessagesService);
}
break;
case RequestType.MessagesRead:
{
requestHandler = new MessagesReadRequestHandler(
request,
clientConnection,
appServiceProvider.NodeNoticeService,
appServiceProvider.ConversationsNoticeService,
appServiceProvider.UpdateMessagesService,
appServiceProvider.LoadDialogsService);
}
break;
case RequestType.GetUsersInformationNode:
{
requestHandler = new GetUsersInfoNodeRequestHandler(request, appServiceProvider.LoadUsersService, appServiceProvider.PrivacyService);
}
break;
case RequestType.GetChatsInformationNode:
{
requestHandler = new GetChatsInfoNodeRequestHandler(request, appServiceProvider.LoadChatsService);
}
break;
case RequestType.GetInformationWeb:
{
requestHandler = new GetInformationWebRequestHandler(request, appServiceProvider.NodesService);
}
break;
case RequestType.DeleteUser:
{
requestHandler = new DeleteUserRequestHandler(
request,
clientConnection,
appServiceProvider.NodeNoticeService,
appServiceProvider.DeleteUsersService,
appServiceProvider.VerificationCodesService,
appServiceProvider.ConnectionsService);
}
break;
case RequestType.BlockUsers:
{
requestHandler = new BlockUsersRequestHandler(request, clientConnection, appServiceProvider.NodeNoticeService, appServiceProvider.UpdateUsersService);
}
break;
case RequestType.GetSelf:
{
requestHandler = new GetSelfRequestHandler(request, clientConnection, appServiceProvider.LoadUsersService);
}
break;
case RequestType.GetChatUsers:
{
requestHandler = new GetChatUsersRequestHandler(
request,
clientConnection,
appServiceProvider.LoadChatsService,
appServiceProvider.PrivacyService,
appServiceProvider.ConnectionsService,
appServiceProvider.NodeRequestSender,
appServiceProvider.CrossNodeService);
}
break;
case RequestType.EditChatUsers:
{
requestHandler = new EditChatUsersRequestHandler(
request,
clientConnection,
appServiceProvider.NodeNoticeService,
appServiceProvider.ConversationsNoticeService,
appServiceProvider.LoadChatsService,
appServiceProvider.UpdateChatsService,
appServiceProvider.SystemMessagesService);
}
break;
case RequestType.UnblockUsers:
{
requestHandler = new UnblockUsersRequestHandler(request, clientConnection, appServiceProvider.NodeNoticeService, appServiceProvider.UpdateUsersService);
}
break;
case RequestType.GetFilesInformation:
{
requestHandler = new GetFilesInfoRequestHandler(request, clientConnection, appServiceProvider.FilesService);
}
break;
case RequestType.GetAllUserConversationsNode:
{
requestHandler = new GetAllUserConversationsNodeRequestHandler(request, clientConnection, appServiceProvider.ConversationsService);
}
break;
case RequestType.DeleteFiles:
{
requestHandler = new DeleteFilesRequestHandler(request, clientConnection, appServiceProvider.NodeNoticeService, appServiceProvider.FilesService);
}
break;
case RequestType.GetUsers:
{
requestHandler = new GetUsersRequestHandler(request, clientConnection, appServiceProvider.ConnectionsService, appServiceProvider.LoadUsersService, appServiceProvider.PrivacyService, appServiceProvider.NodeRequestSender);
}
break;
case RequestType.DeleteMessages:
{
requestHandler = new DeleteMessagesRequestHandler(
request,
clientConnection,
appServiceProvider.NodeNoticeService,
appServiceProvider.ConversationsNoticeService,
appServiceProvider.DeleteMessagesService,
appServiceProvider.LoadChatsService,
appServiceProvider.PendingMessagesService,
appServiceProvider.LoadChannelsService,
appServiceProvider.LoadDialogsService);
}
break;
case RequestType.GetMessagesUpdates:
{
requestHandler = new GetMessagesUpdatesRequestHandler(request, clientConnection, appServiceProvider.LoadMessagesService);
}
break;
case RequestType.GetChats:
{
requestHandler = new GetChatsRequestHandler(request, appServiceProvider.LoadChatsService, clientConnection);
}
break;
case RequestType.GetDialogsInformation:
{
requestHandler = new GetDialogsInformationRequestHandler(request, clientConnection, appServiceProvider.LoadDialogsService);
}
break;
case RequestType.Search:
{
requestHandler = new SearchRequestHandler(
request,
clientConnection,
appServiceProvider.ConnectionsService,
appServiceProvider.LoadChatsService,
appServiceProvider.NodesService,
appServiceProvider.LoadUsersService,
appServiceProvider.LoadChannelsService,
appServiceProvider.PrivacyService,
appServiceProvider.NodeRequestSender);
}
break;
case RequestType.SetNewKeys:
{
requestHandler = new SetNewKeysRequestHandler(request, clientConnection, appServiceProvider.NodeNoticeService, appServiceProvider.KeysService);
}
break;
case RequestType.DeleteKeys:
{
requestHandler = new DeleteKeysRequestHandler(request, clientConnection, appServiceProvider.NodeNoticeService, appServiceProvider.KeysService);
}
break;
case RequestType.GetRandomSequence:
{
requestHandler = new GetRandomSequenceRequestHandler(request, clientConnection);
}
break;
case RequestType.SetNewKeyForChat:
{
requestHandler = new SetNewKeysRequestHandler(request, clientConnection, appServiceProvider.NodeNoticeService, appServiceProvider.KeysService);
}
break;
case RequestType.GetUserPublicKeys:
{
requestHandler = new GetUserPublicKeysRequestHandler(request, clientConnection, appServiceProvider.KeysService);
}
break;
case RequestType.CreateChannel:
{
requestHandler = new CreateChannelRequestHandler(
request,
clientConnection,
appServiceProvider.NodeNoticeService,
appServiceProvider.ConversationsNoticeService,
appServiceProvider.LoadChannelsService,
appServiceProvider.CreateChannelsService);
}
break;
case RequestType.AddUsersToChannels:
{
requestHandler = new AddUsersToChannelsRequestHandler(
request,
clientConnection,
appServiceProvider.NodeNoticeService,
appServiceProvider.ConversationsNoticeService,
appServiceProvider.UpdateChannelsService,
appServiceProvider.LoadChannelsService,
appServiceProvider.ConnectionsService,
appServiceProvider.NodeRequestSender);
}
break;
case RequestType.EditChannel:
{
requestHandler = new EditChannelRequestHandler(
request,
clientConnection,
appServiceProvider.NodeNoticeService,
appServiceProvider.ConversationsNoticeService,
appServiceProvider.LoadChannelsService,
appServiceProvider.UpdateChannelsService,
appServiceProvider.SystemMessagesService);
}
break;
case RequestType.EditChannelUsers:
{
requestHandler = new EditChannelUsersRequestHandler(
request,
clientConnection,
appServiceProvider.NodeNoticeService,
appServiceProvider.LoadChannelsService,
appServiceProvider.UpdateChannelsService);
}
break;
case RequestType.GetChannelUsers:
{
requestHandler = new GetChannelUsersRequestHandler(request, clientConnection, appServiceProvider.LoadChannelsService);
}
break;
case RequestType.GetChannels:
{
requestHandler = new GetChannelsRequestHandler(request, clientConnection, appServiceProvider.LoadChannelsService);
}
break;
case RequestType.SetConnectionEncrypted:
{
requestHandler = new SetConnectionEncryptedRequestHandler(request, clientConnection,
appServiceProvider.ConnectionsService,
appServiceProvider.KeysService,
appServiceProvider.NodeRequestSender);
}
break;
case RequestType.ChangeNode:
{
requestHandler = new ChangeNodeRequestHandler(request, clientConnection, appServiceProvider.ChangeNodeOperationsService);
}
break;
case RequestType.Polling:
{
requestHandler = new PollingRequestHandler(
request,
clientConnection,
appServiceProvider.NodeNoticeService,
appServiceProvider.LoadChatsService,
appServiceProvider.PollsService,
appServiceProvider.LoadChannelsService);
}
break;
case RequestType.GetPollVotedUsers:
{
requestHandler = new GetPollVotedUsersRequestHandler(request, clientConnection,
appServiceProvider.ConnectionsService,
appServiceProvider.PollsService,
appServiceProvider.NodeRequestSender);
}
break;
case RequestType.EditMessage:
{
requestHandler = new EditMessageRequestHandler(
request,
clientConnection,
appServiceProvider.NodeNoticeService,
appServiceProvider.ConversationsNoticeService,
appServiceProvider.UpdateMessagesService,
appServiceProvider.AttachmentsService);
}
break;
case RequestType.CreateOrEditContact:
{
requestHandler = new CreateOrEditContactRequestHandler(request, clientConnection, appServiceProvider.ContactsService);
}
break;
case RequestType.DeleteContacts:
{
requestHandler = new DeleteContactsRequestHandler(request, clientConnection, appServiceProvider.ContactsService);
}
break;
case RequestType.GetUserContacts:
{
requestHandler = new GetUserContactsRequestHandler(request, clientConnection,
appServiceProvider.ConnectionsService,
appServiceProvider.ContactsService,
appServiceProvider.NodeRequestSender);
}
break;
case RequestType.CreateOrEditGroup:
{
requestHandler = new CreateOrEditGroupRequestHandler(request, clientConnection, appServiceProvider.GroupsService);
}
break;
case RequestType.DeleteGroup:
{
requestHandler = new DeleteGroupRequestHandler(request, clientConnection, appServiceProvider.GroupsService);
}
break;
case RequestType.AddUsersToGroup:
{
requestHandler = new AddUsersToGroupRequestHandler(request, clientConnection, appServiceProvider.GroupsService);
}
break;
case RequestType.RemoveUsersFromGroup:
{
requestHandler = new RemoveUsersFromGroupRequestHandler(request, clientConnection, appServiceProvider.GroupsService);
}
break;
case RequestType.GetGroupContacts:
{
requestHandler = new GetGroupContactsRequestHandler(request, clientConnection,
appServiceProvider.ConnectionsService,
appServiceProvider.GroupsService,
appServiceProvider.NodeRequestSender);
}
break;
case RequestType.GetUserGroups:
{
requestHandler = new GetUserGroupsRequestHandler(request, clientConnection, appServiceProvider.GroupsService);
}
break;
case RequestType.GetMessageEditHistory:
{
requestHandler = new GetMessageEditHistoryRequestHandler(request, clientConnection, appServiceProvider.LoadMessagesService);
}
break;
case RequestType.GetFavorites:
{
requestHandler = new GetFavoritesRequestHandler(request, clientConnection, appServiceProvider.FavoritesService);
}
break;
case RequestType.AddFavorites:
{
requestHandler = new AddFavoritesRequestHandler(request, clientConnection, appServiceProvider.FavoritesService);
}
break;
case RequestType.EditFavorites:
{
requestHandler = new EditFavoritesRequestHandler(request, clientConnection, appServiceProvider.FavoritesService);
}
break;
case RequestType.VerifyNode:
{
requestHandler = new VerifyNodeRequestHandler(request);
}
break;
case RequestType.GetDevicesPrivateKeys:
{
requestHandler = new GetDevicesPrivateKeysRequestHandler(request, clientConnection, clientRequestService, appServiceProvider.ConnectionsService);
}
break;
case RequestType.GetSessions:
{
requestHandler = new GetSessionsRequestHandler(request, clientConnection, appServiceProvider.LoadUsersService);
}
break;
case RequestType.SearchMessages:
{
requestHandler = new SearchMessagesRequestHandler(request, clientConnection, appServiceProvider.LoadMessagesService);
}
break;
case RequestType.MuteConversation:
{
requestHandler = new MuteConversationRequestHandler(request, clientConnection, appServiceProvider.ConversationsService);
}
break;
case RequestType.GetQRCode:
{
requestHandler = new GetQRCodeRequestHandler(request, clientConnection, appServiceProvider.QRCodesService);
}
break;
case RequestType.CheckQRCode:
{
requestHandler = new CheckQRCodeRequestHandler(
request,
clientConnection,
appServiceProvider.NoticeService,
appServiceProvider.QRCodesService,
appServiceProvider.LoadUsersService);
}
break;
case RequestType.BatchPhonesSearch:
{
requestHandler = new BatchPhonesSearchRequestHandler(request, clientConnection,
appServiceProvider.LoadUsersService,
appServiceProvider.ConnectionsService,
appServiceProvider.PrivacyService,
appServiceProvider.NodeRequestSender);
}
break;
case RequestType.ChangeEmailOrPhone:
{
requestHandler = new ChangeEmailOrPhoneRequestHandler(request, clientConnection,
appServiceProvider.UpdateUsersService,
appServiceProvider.VerificationCodesService,
appServiceProvider.LoadUsersService);
}
break;
case RequestType.DeleteAllMessages:
{
requestHandler = new DeleteAllMessagesRequestHandler(request, clientConnection, appServiceProvider.DeleteMessagesService, appServiceProvider.NodeNoticeService);
}
break;
case RequestType.ConversationAction:
{
requestHandler = new ConversationActionRequestHandler(request,
clientConnection,
appServiceProvider.ConversationsService,
appServiceProvider.ConversationsNoticeService,
appServiceProvider.NodeNoticeService,
appServiceProvider.LoadDialogsService,
appServiceProvider.SystemMessagesService);
}
break;
default:
throw new UnknownRequestTypeException();
}
return(requestHandler);
}
