public async void Init(NavigationParameters parameters)
{
if (parameters != null)
{
if (parameters.Logout)
{
LogOutCommand.Execute(null);
}
CanGoBack = parameters.CanGoBack;
ForegroundColor = parameters.ForegroundColor;
BackgroundColor = parameters.BackgroundColor;
if (!string.IsNullOrEmpty(parameters.Realm) && !string.IsNullOrEmpty(parameters.ServiceNamespace))
{
_serviceListEndpoint =
_identityProviderClient.GetDefaultIdentityProviderListServiceEndpoint(parameters.Realm,
parameters.ServiceNamespace);
}
else
{
_serviceListEndpoint = _identityProviderClient.GetDefaultIdentityProviderListServiceEndpoint();
}
}
else
{
_serviceListEndpoint = _identityProviderClient.GetDefaultIdentityProviderListServiceEndpoint();
}
await ReloadIdentityProviders();
}
public MainWindowViewModel()
{
#region starting view content
logHandler = LogHandler.Instance;
logHandler.MainWindowViewModel = this;
ContentHandler.StartContent();
Refresh();
#endregion
#region Commands
AddUserCommand = new AddUserCommand(this);
ViewProfilInfoCommand = new ViewProfilInfoCommand(this);
AddTelephoneCommand = new AddTelephoneCommand(this);
AddShopCommand = new AddShopCommand(this);
ChangeTelephoneCommand = new ChangeTelephoneInfoCommand(this);
DeleteTelephoneCommand = new DeleteTelephoneCommand(this);
DuplicateTelephoneCommand = new DuplicateTelephoneCommand(this);
ChangeShopCommand = new ChangeShopInfoCommand(this);
DeleteShopCommand = new DeleteShopCommand(this);
LogOutCommand = new LogOutCommand(this);
BuyTelephoneCommand = new BuyTelephoneCommand(this);
ClearCommand = new ClearCommand(this);
UndoCommand = new UndoCommand(this);
RedoCommand = new RedoCommand(this);
FilterCommand = new FilterCommand(this);
RefreshCommand = new RefreshCommand(this);
#endregion
}
public async Task Handle_When_CurrentUserService_Token_NullOrWhiteSpace_Should_Not_Call_JwtBlacklistService(string token)
{
_currentUserServiceMock.SetupGet(x => x.Token).Returns(token);
var command = new LogOutCommand();
var handler = new LogOutCommand.Handler(_currentUserServiceMock.Object, _jwtBlacklistServiceMock.Object);
await handler.Handle(command, CancellationToken.None);
_jwtBlacklistServiceMock.Verify(x => x.BlacklistToken(It.IsAny <string>()), Times.Never);
}
public async Task Handle_Should_Call_JwtBlacklistService_Blacklist_Token()
{
_currentUserServiceMock.SetupGet(x => x.Token).Returns("TOKEN");
var command = new LogOutCommand();
var handler = new LogOutCommand.Handler(_currentUserServiceMock.Object, _jwtBlacklistServiceMock.Object);
await handler.Handle(command, CancellationToken.None);
_jwtBlacklistServiceMock.Verify(x => x.BlacklistToken("TOKEN"), Times.Once);
}
//Initialize Data
public ViewModel()
{
Authenticator = new Authenticator(this);
_LogOnCommand = new LogOnCommand(this);
_LogOutCommand = new LogOutCommand(this);
ResultTextData = new ResultTextData();
//Create a Sampleinstace for Authenticationdata
AuthData = new AuthenticationData();
}
public MainWindowViewModel()
{
PageUri = new Uri("Pages/LogInPage.xaml", UriKind.Relative);
IsWorking = false;
LogInPageCommand = new LogInPageCommand(this);
WorkPageCommand = new WorkPageCommand(this);
AdministratorPageCommand = new AdministratorPageCommand(this);
LogOutCommand = new LogOutCommand(this);
QuitCommand = new QuitCommand();
}
public MainWindowViewModel()
{
mainWindowModel = new MainWindowModel();
initLogIn();
HomeCommand = new HomeCommand();
LogOutCommand = new LogOutCommand();
DailyFoodCommand = new DailyFoodCommand();
WeekGoalsCommand = new WeekGoalsCommand();
SearchCommand = new SearchFoodCommand();
WeekDetailsCommand = new WeekDetailsCommand();
}
public void OneSetUp()
{
viewProjectsCommand = new ViewProjectsCommand();
addEmployeeCommand = new AddEmployeeCommand();
changePasswordCommand = new ChangePasswordCommand();
editPersonalDataCommand = new EditPersonalDataCommand();
sendRequestCompanyViewCommand = new SendRequestCompanyViewCommand();
viewWorkersCommand = new ViewWorkersCommand();
workingHoursCommand = new WorkingHoursCommand();
logOutCommand = new LogOutCommand();
signInCommand = new SignInCommand();
defineUserStoriesCommand = new DefineUserStoriesCommand();
createProjectCommand = new CreateProjectCommand();
showCompaniesCommand = new ShowCompaniesCommand();
sendRequestProjectViewCommand = new SendRequestProjectViewCommand();
markProjectFinishedCommand = new MarkProjectFinishedCommand();
loadedCommand = new LoadedCommand();
editPositionCommand = new EditPositionCommand();
clientDialogViewModelUnderTest = new ClientDialogViewModel();
clientDialogViewModelUnderTest.AddEmployeeCommand = addEmployeeCommand;
clientDialogViewModelUnderTest.ChangePasswordCommand = changePasswordCommand;
clientDialogViewModelUnderTest.CreateProjectCommand = createProjectCommand;
clientDialogViewModelUnderTest.DefineUserStoriesCommand = defineUserStoriesCommand;
clientDialogViewModelUnderTest.EditPersonalDataCommand = editPersonalDataCommand;
clientDialogViewModelUnderTest.EditPositionCommand = editPositionCommand;
clientDialogViewModelUnderTest.ErrorMessage = "";
clientDialogViewModelUnderTest.LoadedCommand = loadedCommand;
clientDialogViewModelUnderTest.LogInUser = new LogInUser();
clientDialogViewModelUnderTest.LogOutCommand = logOutCommand;
clientDialogViewModelUnderTest.MarkProjectFinishedCommand = markProjectFinishedCommand;
clientDialogViewModelUnderTest.SendRequestCompanyViewCommand = sendRequestCompanyViewCommand;
clientDialogViewModelUnderTest.SendRequestProjectViewCommand = sendRequestProjectViewCommand;
clientDialogViewModelUnderTest.ShowCompaniesCommand = showCompaniesCommand;
clientDialogViewModelUnderTest.SignInCommand = signInCommand;
clientDialogViewModelUnderTest.ViewProjectsCommand = viewProjectsCommand;
clientDialogViewModelUnderTest.ViewWorkersCommand = viewWorkersCommand;
clientDialogViewModelUnderTest.Resources = new ObservableCollection <Employee>();
clientDialogViewModelUnderTest.PrResources = new ObservableCollection <Project>();
clientDialogViewModelUnderTest.EmpResource = new ObservableCollection <Employee>();
clientDialogViewModelUnderTest.OcResources = new ObservableCollection <OutsourcingCompany>();
clientDialogViewModelUnderTest.UsResources = new ObservableCollection <UserStory>();
LogInUser nov = clientDialogViewModelUnderTest.LogInUser;
string str = clientDialogViewModelUnderTest.ErrorMessage;
ObservableCollection <Employee> res1 = clientDialogViewModelUnderTest.Resources;
ObservableCollection <Project> res2 = clientDialogViewModelUnderTest.PrResources;
ObservableCollection <Employee> res3 = clientDialogViewModelUnderTest.EmpResource;
ObservableCollection <OutsourcingCompany> res4 = clientDialogViewModelUnderTest.OcResources;
ObservableCollection <UserStory> res5 = clientDialogViewModelUnderTest.UsResources;
}
public void SetupTest()
{
this.logOutCommandUnderTest = new LogOutCommand();
this.logOutCommandUnderTest.CanExecuteChanged += (object sender, EventArgs e) => { Console.WriteLine("CanExecuteChanged"); };
EmployeeDB.Instance = Substitute.For <IEmployeeDB>();
ClientDialogViewModel.Instance = Substitute.For <IClientDialogViewModel>();
ClientDialogViewModel.Instance.LogInUser().Returns(new LogInUser("mica", "mica"));
ClientProxy.Instance = Substitute.For <IHiringCompany>();
ClientProxy.Instance.EmployeeLogOut("mica").ReturnsForAnyArgs(true);
}
/// <summary>
/// Refreshes the bundles page to reload the albums if authenticated, or else clear the bundles page.
/// </summary>
public override void Refresh()
{
if (IsAuthenticated && HasInternetConnection)
{
IsLoading = true;
LoadAlbumsAsync();
LoadDisplayName();
}
else
{
Reset();
}
AuthenticateCommand.RaiseCanExecuteChanged();
SyncCommand.RaiseCanExecuteChanged();
LogOutCommand.RaiseCanExecuteChanged();
}
public ActionResult LogOut(LogOutCommand command)
{
string message; User user;
if ((user = _repository.GetUserByToken(command.user_token)) != null)
{
user.Token = _profileCondition.GenerateHash(40);
_repository.UpdateUser(user);
_logger.LogInformation($"Log out user, id -> {user.Id}.");
return(Ok(new MessageResponse(true, "Log out is successfully.")));
}
else
{
message = "Server can't define user by token.";
}
_logger.LogWarning(message);
var response = new MessageResponse(false, message);
return(StatusCode(500, response));
}
public CategoriesListViewModel(IProductService service, IAppNavigation navi, IScanner scanner, LogOutCommand logOut)
{
_service = service;
_navi = navi;
_scanner = scanner;
_logOut = logOut;
MessagingCenter.Subscribe <Category>(this, Messages.NavigateTo, NavigateToCategory);
_searchCommand = new RelayCommand(Search, () => !string.IsNullOrWhiteSpace(SearchTerm));
ScanCommand = new RelayCommand(async() =>
{
var result = await _scanner.Scan();
SearchTerm = result.Text;
Search();
});
Categories = new NotifyTaskCompletion <List <CategoryViewModel> >(GetCategories());
}
private void DoLoginSelectedIdentity(DefaultIdentityProviderViewModel provider)
{
try
{
LogOutCommand.Execute(null);
_loginIdentityProviderTask.LogIn(provider.LoginUrl, OnLoggedIn, AssumeCancelled, provider.Name, CanGoBack);
}
catch (Exception e)
{
if (LoginError != null)
{
LoginError(this,
new LoginErrorEventArgs
{
Exception = e,
Message = "An exception occured when attempting to log in."
});
}
}
}
public string DispatchCommand(string[] commandParameters)
{
var command = commandParameters[0];
if (loggedInUserCommands.Contains(command) && Session.User == null)
{
throw new InvalidOperationException("Invalid credentials!");
}
var args = commandParameters.Skip(1).ToArray();
var returnValue = "";
switch (command)
{
case "Login":
returnValue = LogInCommand.Execute(args);
break;
case "RegisterUser":
returnValue = RegisterUserCommand.Execute(args);
break;
case "ListFriends":
returnValue = PrintFriendsListCommand.Execute(args);
break;
case "Logout":
returnValue = LogOutCommand.Execute(args);
break;
case "AddTown":
returnValue = AddTownCommand.Execute(args);
break;
case "ModifyUser":
returnValue = ModifyUserCommand.Execute(args);
break;
case "DeleteUser":
returnValue = DeleteUser.Execute(args);
break;
case "AddTag":
returnValue = AddTagCommand.Execute(args);
break;
case "CreateAlbum":
returnValue = CreateAlbumCommand.Execute(args);
break;
case "AddTagTo":
returnValue = AddTagToCommand.Execute(args);
break;
case "AddFriend":
returnValue = AddFriendCommand.Execute(args);
break;
case "AcceptFriend":
returnValue = AcceptFriendCommand.Execute(args);
break;
case "ShareAlbum":
returnValue = ShareAlbumCommand.Execute(args);
break;
case "UploadPicture":
returnValue = UploadPictureCommand.Execute(args);
break;
case "Exit":
returnValue = ExitCommand.Execute();
break;
default:
throw new InvalidOperationException($"Command {command} not valid!");
}
return(returnValue);
}
private void ProcessCommands(string commands)
{
string commandType = String.Join(string.Empty, commands.Split());
ICommand command = null;
string commandResult = String.Empty;
switch (commandType)
{
case "register":
case "registeruser":
command = new RegisterCommand();
break;
case "login":
case "log":
command = new LoginCommand();
break;
case "logout":
command = new LogOutCommand();
break;
case "addnotebook":
command = new AddNotebookCommand();
break;
case "addnote":
if (LoggedUser.Notebooks.Count == 0)
{
throw new ArgumentException(Messages.MustCreateANotebook());
}
command = new AddNoteCommand();
break;
case "switchnotebook":
command = new SwitchNotebookCommand();
break;
case "addtask":
command = new AddTaskCommand();
break;
case "addlongtermtask":
command = new AddLongTermTaskCommand();
break;
case "addsubtask":
command = new AddSubtaskCommand();
break;
case "addremindertotask":
command = new AddReminderToTaskCommand();
break;
case "addnotetofavourites":
command = new AddNoteToFavouritesCommand();
break;
case "addnotebooktofavourites":
command = new AddNotebookToFavouritesCommand();
break;
case "listall":
command = new ListCommand();
break;
case "listtask":
command = new ListTask();
break;
case "listnotebook":
command = new ListNotebookCommand();
break;
case "listnote":
command = new ListNoteCommand();
break;
case "listlongtermtask":
command = new ListLongTermTaskCommand();
break;
case "listsubtask":
command = new ListSubTaskCommand();
break;
case "switchlongtertask":
command = new SwitchLongTermTaskCommand();
break;
case "deletetask":
command = new DeleteTaskCommand();
break;
case "deletesubtask":
command = new DeleteSubTaskCommand();
break;
case "clearhistory":
command = new ClearHistoryCommand();
break;
case "sortallnotebooks":
command = new SortNotebooksCommand();
break;
case "sortnotebook":
command = new SortNotebookCommand();
break;
case "sorttasks":
command = new SortTasksCommand();
break;
default:
throw new ArgumentException("Wrong Command");
}
command.TakeInput();
commandResult = command.Execute();
Writer.WriteLine(commandResult);
}
public string DispatchCommand(string[] commandParameters)
{
string command = commandParameters[0].ToLower();
User user = new User();
string result = null;
using (PhotoShareContext context = new PhotoShareContext())
{
switch (command)
{
case "registeruser":
result = RegisterUserCommand.Execute(commandParameters); break;
case "addtown":
result = AddTownCommand.Execute(commandParameters); break;
case "modifyuser":
result = ModifyUserCommand.Execute(commandParameters); break;
case "deleteuser":
result = DeleteUser.Execute(commandParameters); break;
case "addtag":
result = AddTagCommand.Execute(commandParameters); break;
case "addfriend":
result = AddFriendCommand.Execute(commandParameters); break;
case "acceptfriend":
result = AcceptFriendCommand.Execute(commandParameters); break;
case "createalbum":
result = CreateAlbumCommand.Execute(commandParameters); break;
case "uploadpicture":
result = UploadPictureCommand.Execute(commandParameters); break;
case "listfriends":
result = PrintFriendsListCommand.Execute(commandParameters); break;
case "addtagto":
result = AddTagToCommand.Execute(commandParameters); break;
case "sharealbum":
result = ShareAlbumCommand.Execute(commandParameters); break;
case "login":
result = LoginCommand.Execute(commandParameters, context); break;
case "logout":
result = LogOutCommand.Execute(commandParameters, context); break;
case "exit":
result = ExitCommand.Execute(); break;
default:
throw new InvalidOperationException($"Command {command} not valid!");
}
}
return(result);
}
protected override void OnReceived(byte[] body)
{
ByteArrayArrayStream stream = new ByteArrayArrayStream(body);
ByteArrayStreamReader reader = new ByteArrayStreamReader(stream);
try
{
if (Adler32.Generate(body, 4) == reader.ReadUInt())
{
if (Keys == null)
{
Rsa.DecryptAndReplace(body, 9);
}
else
{
Xtea.DecryptAndReplace(body, 4, 32, Keys);
stream.Seek(Origin.Current, 2);
}
Command command = null;
switch (reader.ReadByte())
{
case 0x0A:
{
var packet = server.PacketsFactory.Create <SelectedCharacterIncomingPacket>(reader);
command = new LogInCommand(this, packet);
}
break;
case 0x14:
command = new LogOutCommand(Client.Player);
break;
case 0x1E:
command = new PongCommand(Client.Player);
break;
case 0x64:
{
var packet = server.PacketsFactory.Create <WalkToIncomingPacket>(reader);
command = new WalkToKnownPathCommand(Client.Player, packet.MoveDirections);
}
break;
case 0x65:
command = new WalkCommand(Client.Player, MoveDirection.North);
break;
case 0x66:
command = new WalkCommand(Client.Player, MoveDirection.East);
break;
case 0x67:
command = new WalkCommand(Client.Player, MoveDirection.South);
break;
case 0x68:
command = new WalkCommand(Client.Player, MoveDirection.West);
break;
case 0x69:
command = new StopWalkCommand(Client.Player);
break;
case 0x6A:
command = new WalkCommand(Client.Player, MoveDirection.NorthEast);
break;
case 0x6B:
command = new WalkCommand(Client.Player, MoveDirection.SouthEast);
break;
case 0x6C:
command = new WalkCommand(Client.Player, MoveDirection.SouthWest);
break;
case 0x6D:
command = new WalkCommand(Client.Player, MoveDirection.NorthWest);
break;
case 0x6F:
command = new TurnCommand(Client.Player, Direction.North);
break;
case 0x70:
command = new TurnCommand(Client.Player, Direction.East);
break;
case 0x71:
command = new TurnCommand(Client.Player, Direction.South);
break;
case 0x72:
command = new TurnCommand(Client.Player, Direction.West);
break;
case 0x78:
{
var packet = server.PacketsFactory.Create <MoveItemIncomingPacket>(reader);
Position fromPosition = new Position(packet.FromX, packet.FromY, packet.FromZ);
Position toPosition = new Position(packet.ToX, packet.ToY, packet.ToZ);
if (fromPosition.IsContainer)
{
if (toPosition.IsContainer)
{
command = new MoveItemFromContainerToContainerCommand(Client.Player, fromPosition.ContainerId, fromPosition.ContainerIndex, packet.FromItemId, toPosition.ContainerId, toPosition.ContainerIndex, packet.Count);
}
else if (toPosition.IsInventory)
{
command = new MoveItemFromContainerToInventoryCommand(Client.Player, fromPosition.ContainerId, fromPosition.ContainerIndex, packet.FromItemId, toPosition.InventoryIndex, packet.Count);
}
else
{
command = new MoveItemFromContainerToTileCommand(Client.Player, fromPosition.ContainerId, fromPosition.ContainerIndex, packet.FromItemId, toPosition, packet.Count);
}
}
else if (fromPosition.IsInventory)
{
if (toPosition.IsContainer)
{
command = new MoveItemFromInventoryToContainerCommand(Client.Player, fromPosition.InventoryIndex, packet.FromItemId, toPosition.ContainerId, toPosition.ContainerIndex, packet.Count);
}
else if (toPosition.IsInventory)
{
command = new MoveItemFromInventoryToInventoryCommand(Client.Player, fromPosition.InventoryIndex, packet.FromItemId, toPosition.InventoryIndex, packet.Count);
}
else
{
command = new MoveItemFromInventoryToTileCommand(Client.Player, fromPosition.InventoryIndex, packet.FromItemId, toPosition, packet.Count);
}
}
else
{
if (toPosition.IsContainer)
{
command = new MoveItemFromTileToContainerCommand(Client.Player, fromPosition, packet.FromIndex, packet.FromItemId, toPosition.ContainerId, toPosition.ContainerIndex, packet.Count);
}
else if (toPosition.IsInventory)
{
command = new MoveItemFromTileToInventoryCommand(Client.Player, fromPosition, packet.FromIndex, packet.FromItemId, toPosition.InventoryIndex, packet.Count);
}
else
{
command = new MoveItemFromTileToTileCommand(Client.Player, fromPosition, packet.FromIndex, packet.FromItemId, toPosition, packet.Count);
}
}
}
break;
case 0x79:
{
var packet = server.PacketsFactory.Create <LookItemNpcTradeIncommingPacket>(reader);
command = new LookFromNpcTradeCommand(Client.Player, packet.ItemId, packet.Type);
}
break;
case 0x7A:
{
var packet = server.PacketsFactory.Create <BuyNpcTradeIncommingPacket>(reader);
command = new BuyNpcTradeCommand(Client.Player, packet);
}
break;
case 0x7B:
{
var packet = server.PacketsFactory.Create <SellNpcTradeIncommingPacket>(reader);
command = new SellNpcTradeCommand(Client.Player, packet);
}
break;
case 0x7C:
command = new CloseNpcTradeCommand(Client.Player);
break;
case 0x7D:
{
var packet = server.PacketsFactory.Create <TradeWithIncommingPacket>(reader);
Position fromPosition = new Position(packet.X, packet.Y, packet.Z);
if (fromPosition.IsContainer)
{
command = new TradeWithFromContainerCommand(Client.Player, fromPosition.ContainerId, fromPosition.ContainerIndex, packet.ItemId, packet.CreatureId);
}
else if (fromPosition.IsInventory)
{
command = new TradeWithFromInventoryCommand(Client.Player, fromPosition.InventoryIndex, packet.ItemId, packet.CreatureId);
}
else
{
command = new TradeWithFromTileCommand(Client.Player, fromPosition, packet.Index, packet.ItemId, packet.CreatureId);
}
}
break;
case 0x7E:
{
var packet = server.PacketsFactory.Create <LookItemTradeIncommingPacket>(reader);
command = new LookFromTradeCommand(Client.Player, packet.WindowId, packet.Index);
}
break;
case 0x7F:
command = new AcceptTradeCommand(Client.Player);
break;
case 0x80:
command = new CancelTradeCommand(Client.Player);
break;
case 0x82:
{
var packet = server.PacketsFactory.Create <UseItemIncomingPacket>(reader);
Position fromPosition = new Position(packet.X, packet.Y, packet.Z);
if (fromPosition.IsContainer)
{
command = new UseItemFromContainerCommand(Client.Player, fromPosition.ContainerId, fromPosition.ContainerIndex, packet.ItemId, packet.ContainerId);
}
else if (fromPosition.IsInventory)
{
command = new UseItemFromInventoryCommand(Client.Player, fromPosition.InventoryIndex, packet.ItemId);
}
else
{
command = new UseItemFromTileCommand(Client.Player, fromPosition, packet.Index, packet.ItemId);
}
}
break;
case 0x83:
{
var packet = server.PacketsFactory.Create <UseItemWithItemIncomingPacket>(reader);
Position fromPosition = new Position(packet.FromX, packet.FromY, packet.FromZ);
Position toPosition = new Position(packet.ToX, packet.ToY, packet.ToZ);
if (fromPosition.IsContainer)
{
if (toPosition.IsContainer)
{
command = new UseItemWithItemFromContainerToContainerCommand(Client.Player, fromPosition.ContainerId, fromPosition.ContainerIndex, packet.FromItemId, toPosition.ContainerId, toPosition.ContainerIndex, packet.ToItemId);
}
else if (toPosition.IsInventory)
{
command = new UseItemWithItemFromContainerToInventoryCommand(Client.Player, fromPosition.ContainerId, fromPosition.ContainerIndex, packet.FromItemId, toPosition.InventoryIndex, packet.ToItemId);
}
else
{
command = new UseItemWithItemFromContainerToTileCommand(Client.Player, fromPosition.ContainerId, fromPosition.ContainerIndex, packet.FromItemId, toPosition, packet.ToIndex, packet.ToItemId);
}
}
else if (fromPosition.IsInventory)
{
if (toPosition.IsContainer)
{
command = new UseItemWithItemFromInventoryToContainerCommand(Client.Player, fromPosition.InventoryIndex, packet.FromItemId, toPosition.ContainerId, toPosition.ContainerIndex, packet.ToItemId);
}
else if (toPosition.IsInventory)
{
command = new UseItemWithItemFromInventoryToInventoryCommand(Client.Player, fromPosition.InventoryIndex, packet.FromItemId, toPosition.InventoryIndex, packet.ToItemId);
}
else
{
command = new UseItemWithItemFromInventoryToTileCommand(Client.Player, fromPosition.InventoryIndex, packet.FromItemId, toPosition, packet.ToIndex, packet.ToItemId);
}
}
else
{
if (toPosition.IsContainer)
{
command = new UseItemWithItemFromTileToContainerCommand(Client.Player, fromPosition, packet.FromIndex, packet.FromItemId, toPosition.ContainerId, toPosition.ContainerIndex, packet.ToItemId);
}
else if (toPosition.IsInventory)
{
command = new UseItemWithItemFromTileToInventoryCommand(Client.Player, fromPosition, packet.FromIndex, packet.FromItemId, toPosition.InventoryIndex, packet.ToItemId);
}
else
{
command = new UseItemWithItemFromTileToTileCommand(Client.Player, fromPosition, packet.FromIndex, packet.FromItemId, toPosition, packet.ToIndex, packet.ToItemId);
}
}
}
break;
case 0x84:
{
var packet = server.PacketsFactory.Create <UseItemWithCreatureIncomingPacket>(reader);
Position fromPosition = new Position(packet.X, packet.Y, packet.Z);
if (fromPosition.IsContainer)
{
command = new UseItemWithCreatureFromContainerCommand(Client.Player, fromPosition.ContainerId, fromPosition.ContainerIndex, packet.ItemId, packet.CreatureId);
}
else if (fromPosition.IsInventory)
{
command = new UseItemWithCreatureFromInventoryCommand(Client.Player, fromPosition.InventoryIndex, packet.ItemId, packet.CreatureId);
}
else
{
command = new UseItemWithCreatureFromTileCommand(Client.Player, fromPosition, packet.Index, packet.ItemId, packet.CreatureId);
}
}
break;
case 0x85:
{
var packet = server.PacketsFactory.Create <RotateItemIncomingPacket>(reader);
var fromPosition = new Position(packet.X, packet.Y, packet.Z);
if (fromPosition.IsContainer)
{
command = new RotateItemFromContainerCommand(Client.Player, fromPosition.ContainerId, fromPosition.ContainerIndex, packet.ItemId);
}
else if (fromPosition.IsInventory)
{
command = new RotateItemFromInventoryCommand(Client.Player, fromPosition.InventoryIndex, packet.ItemId);
}
else
{
command = new RotateItemFromTileCommand(Client.Player, fromPosition, packet.Index, packet.ItemId);
}
}
break;
case 0x87:
{
var packet = server.PacketsFactory.Create <CloseContainerIncommingPacket>(reader);
command = new CloseContainerCommand(Client.Player, packet.ContainerId);
}
break;
case 0x88:
{
var packet = server.PacketsFactory.Create <OpenParentIncommingPacket>(reader);
command = new OpenParentContainerCommand(Client.Player, packet.ContainerId);
}
break;
case 0x8C:
{
var packet = server.PacketsFactory.Create <LookIncomingPacket>(reader);
var fromPosition = new Position(packet.X, packet.Y, packet.Z);
if (fromPosition.IsContainer)
{
command = new LookFromContainerCommand(Client.Player, fromPosition.ContainerId, fromPosition.ContainerIndex, packet.ItemId);
}
else if (fromPosition.IsInventory)
{
command = new LookFromInventoryCommand(Client.Player, fromPosition.InventoryIndex, packet.ItemId);
}
else
{
command = new LookFromTileCommand(Client.Player, fromPosition, packet.Index, packet.ItemId);
}
}
break;
case 0x96:
{
var packet = server.PacketsFactory.Create <TalkIncommingPacket>(reader);
switch (packet.TalkType)
{
case TalkType.Say:
command = new SayCommand(Client.Player, packet.Message);
break;
case TalkType.Whisper:
command = new WhisperCommand(Client.Player, packet.Message);
break;
case TalkType.Yell:
command = new YellCommand(Client.Player, packet.Message);
break;
case TalkType.Private:
command = new SendMessageToPlayerCommand(Client.Player, packet.Name, packet.Message);
break;
case TalkType.ChannelYellow:
command = new SendMessageToChannel(Client.Player, packet.ChannelId, packet.Message);
break;
case TalkType.ReportRuleViolationOpen:
command = new CreateReportRuleViolationCommand(Client.Player, packet.Message);
break;
case TalkType.ReportRuleViolationAnswer:
command = new AnswerInReportRuleViolationChannelCommand(Client.Player, packet.Name, packet.Message);
break;
case TalkType.ReportRuleViolationQuestion:
command = new AskInReportRuleViolationChannelCommand(Client.Player, packet.Message);
break;
case TalkType.Broadcast:
command = new BroadcastMessageCommand(Client.Player, packet.Message);
break;
}
}
break;
case 0x97:
command = new OpenNewChannelCommand(Client.Player);
break;
case 0x98:
{
var packet = server.PacketsFactory.Create <OpenedNewChannelIncomingPacket>(reader);
command = new OpenedNewChannelCommand(Client.Player, packet.ChannelId);
}
break;
case 0x99:
{
var packet = server.PacketsFactory.Create <CloseChannelIncommingPacket>(reader);
command = new CloseChannelCommand(Client.Player, packet.ChannelId);
}
break;
case 0x9A:
{
var packet = server.PacketsFactory.Create <OpenedPrivateChannelIncomingPacket>(reader);
command = new OpenedPrivateChannelCommand(Client.Player, packet.Name);
}
break;
case 0x9B:
{
var packet = server.PacketsFactory.Create <ProcessReportRuleViolationIncommingPacket>(reader);
command = new ProcessReportRuleViolationCommand(Client.Player, packet.Name);
}
break;
case 0x9C:
{
var packet = server.PacketsFactory.Create <CloseReportRuleViolationChannelAnswerIncommingPacket>(reader);
command = new CloseReportRuleViolationChannelAnswerCommand(Client.Player, packet.Name);
}
break;
case 0x9D:
command = new CloseReportRuleViolationChannelQuestionCommand(Client.Player);
break;
case 0x9E:
command = new CloseNpcsChannelCommand(Client.Player);
break;
case 0xA0:
{
var packet = server.PacketsFactory.Create <CombatControlsIncommingPacket>(reader);
command = new CombatControlsCommand(Client.Player, packet.FightMode, packet.ChaseMode, packet.SafeMode);
}
break;
case 0xA1:
{
var packet = server.PacketsFactory.Create <AttackIncommingPacket>(reader);
if (packet.CreatureId == 0)
{
command = new StopAttackCommand(Client.Player);
}
else
{
command = new StartAttackCommand(Client.Player, packet.CreatureId, packet.Nonce);
}
}
break;
case 0xA2:
{
var packet = server.PacketsFactory.Create <FollowIncommingPacket>(reader);
if (packet.CreatureId == 0)
{
command = new StopFollowCommand(Client.Player);
}
else
{
command = new StartFollowCommand(Client.Player, packet.CreatureId, packet.Nonce);
}
}
break;
case 0xA3:
{
var packet = server.PacketsFactory.Create <InviteToPartyIncomingPacket>(reader);
command = new InviteToPartyCommand(Client.Player, packet.CreatureId);
}
break;
case 0xA4:
{
var packet = server.PacketsFactory.Create <JoinPartyIncomingPacket>(reader);
command = new JoinPartyCommand(Client.Player, packet.CreatureId);
}
break;
case 0xA5:
{
var packet = server.PacketsFactory.Create <RevokePartyIncomingPacket>(reader);
command = new RevokePartyCommand(Client.Player, packet.CreatureId);
}
break;
case 0xA6:
{
var packet = server.PacketsFactory.Create <PassLeadershipToIncomingPacket>(reader);
command = new PassLeaderShipToCommand(Client.Player, packet.CreatureId);
}
break;
case 0xA7:
command = new LeavePartyCommand(Client.Player);
break;
case 0xA8:
{
var packet = server.PacketsFactory.Create <SharedExperienceIncomingPacket>(reader);
command = new SharedExperienceCommand(Client.Player, packet.Enabled);
}
break;
case 0xAA:
command = new OpenedMyPrivateChannelCommand(Client.Player);
break;
case 0xAB:
{
var packet = server.PacketsFactory.Create <InvitePlayerIncommingPacket>(reader);
command = new InvitePlayerCommand(Client.Player, packet.Name);
}
break;
case 0xAC:
{
var packet = server.PacketsFactory.Create <ExcludePlayerIncommingPacket>(reader);
command = new ExcludePlayerCommand(Client.Player, packet.Name);
}
break;
case 0xBE:
command = new StopCommand(Client.Player);
break;
case 0xD2:
command = new SelectOutfitCommand(Client.Player);
break;
case 0xD3:
{
var packet = server.PacketsFactory.Create <SelectedOutfitIncomingPacket>(reader);
command = new SelectedOutfitCommand(Client.Player, packet.Outfit);
}
break;
case 0xDC:
{
var packet = server.PacketsFactory.Create <AddVipIncommingPacket>(reader);
command = new AddVipCommand(Client.Player, packet.Name);
}
break;
case 0xDD:
{
var packet = server.PacketsFactory.Create <RemoveVipIncommingPacket>(reader);
command = new RemoveVipCommand(Client.Player, packet.CreatureId);
}
break;
case 0xE6:
{
var packet = server.PacketsFactory.Create <ReportBugIncomingPacket>(reader);
command = new ReportBugCommand(Client.Player, packet.Message);
}
break;
case 0xF0:
command = new OpenQuestsCommand(Client.Player);
break;
case 0xF1:
{
var packet = server.PacketsFactory.Create <OpenQuestIncomingPacket>(reader);
command = new OpenQuestCommand(Client.Player, packet.QuestId);
}
break;
}
if (command != null)
{
server.QueueForExecution(command);
}
}
}
catch (Exception ex)
{
server.Logger.WriteLine(ex.ToString());
}
base.OnReceived(body);
}
public string Dispatch(string input)
{
string[] arguments = input.Split(new char[] { ' ', '\t' }, StringSplitOptions.RemoveEmptyEntries);
string commandName = arguments.Length > 0 ? arguments[0] : string.Empty;
arguments = arguments.Skip(1).ToArray();
switch (commandName)
{
case "RegisterUser":
RegisterUserCommand register = new RegisterUserCommand(authenticationManager);
return(register.Execute(arguments));
case "Login":
LogInCommand login = new LogInCommand(authenticationManager);
return(login.Execute(arguments));
case "Logout":
LogOutCommand logout = new LogOutCommand(authenticationManager);
return(logout.Execute(arguments));
case "DeleteUser":
DeleteUserCommand delete = new DeleteUserCommand(authenticationManager);
return(delete.Execute(arguments));
case "CreateEvent":
CreateEventCommand createEvent = new CreateEventCommand(authenticationManager);
return(createEvent.Execute(arguments));
case "CreateTeam":
CreateTeamCommand createTeam = new CreateTeamCommand(authenticationManager);
return(createTeam.Execute(arguments));
case "InviteToTeam":
InviteToTeamCommand inviteToTeam = new InviteToTeamCommand(authenticationManager);
return(inviteToTeam.Execute(arguments));
case "AcceptInvite":
AcceptInviteCommand acceptInvite = new AcceptInviteCommand(authenticationManager);
return(acceptInvite.Execute(arguments));
case "DeclineInvite":
DeclineInviteCommand declineInvite = new DeclineInviteCommand(authenticationManager);
return(declineInvite.Execute(arguments));
case "KickMember":
KickMemberCommand kickMember = new KickMemberCommand(authenticationManager);
return(kickMember.Execute(arguments));
case "Disband":
DisbandCommand disband = new DisbandCommand(authenticationManager);
return(disband.Execute(arguments));
case "AddTeamTo":
AddTeamToCommand addTeamToCommand = new AddTeamToCommand(authenticationManager);
return(addTeamToCommand.Execute(arguments));
case "ShowEvent":
ShowEventCommand showEvent = new ShowEventCommand(authenticationManager);
return(showEvent.Execute(arguments));
case "ShowTeam":
ShowTeamCommand showTeam = new ShowTeamCommand(authenticationManager);
return(showTeam.Execute(arguments));
case "Exit":
ExitCommand exitCommand = new ExitCommand();
return(exitCommand.Execute(arguments));
default:
throw new NotSupportedException($"Command {commandName} is not supported!");
}
}
public string DispatchCommand(string[] commandParameters)
{
var commands = commandParameters.Select(x => x.ToLower()).ToArray();
if (commands.Length == 5 && commands[0] == "registeruser")
{
return(RegisterUserCommand.Execute(commands));
}
else if (commands[0] == "login" && commands.Length == 3)
{
return(LoginCommand.Execute(commands));
}
if (commands.Length == 3 && commands[0] == "addtown")
{
return(AddTownCommand.Execute(commands));
}
else if (commands.Length == 4 && commands[0] == "modifyuser")
{
return(ModifyUserCommand.Execute(commands));
}
else if (commands.Length == 2 && commands[0] == "deleteuser")
{
return(DeleteUser.Execute(commands));
}
else if (commands.Length == 2 && commands[0] == "addtag")
{
return(AddTagCommand.Execute(commands));
}
else if (commands[0] == "createalbum" && commands.Length >= 5)
{
return(CreateAlbumCommand.Execute(commands));
}
else if (commands[0] == "addtagto" && commands.Length == 3)
{
return(AddTagToCommand.Execute(commands));
}
else if (commands[0] == "addfriend" && commands.Length == 3)
{
return(AddFriendCommand.Execute(commands));
}
else if (commands[0] == "acceptfriend" && commands.Length == 3)
{
return(AcceptFriendCommand.Execute(commands));
}
else if (commands[0] == "listfriends" && commands.Length == 2)
{
return(PrintFriendsListCommand.Execute(commands));
}
else if (commands[0] == "sharealbum" && commands.Length == 4)
{
return(ShareAlbumCommand.Execute(commands));
}
else if (commands[0] == "uploadpicture" && commands.Length == 4)
{
return(UploadPictureCommand.Execute(commands));
}
else if (commands[0] == "logout" && commands.Length == 1)
{
return(LogOutCommand.Execute(commands));
}
else if (commands[0] == "exit" && commands.Length == 1)
{
return(ExitCommand.Execute());
}
return($"Command not valid!");
}
