Exemple #1
0
        public string DispatchCommand(string[] commandParameters)
        {
            var    cmd       = commandParameters[0].ToLower();
            var    cmdParams = commandParameters.Skip(1).ToArray();
            string result    = null;

            switch (cmd)
            {
            case "registeruser":
                result = RegisterUserCommand.Execute(cmdParams);
                break;

            case "addtown":
                result = AddTownCommand.Execute(cmdParams);
                break;

            case "modifyuser":
                result = ModifyUserCommand.Execute(cmdParams);
                break;

            case "deleteuser":
                result = DeleteUser.Execute(cmdParams);
                break;

            case "addtag":
                result = AddTagCommand.Execute(cmdParams);
                break;

            case "addfriend":
                result = AddFriendCommand.Execute(cmdParams);
                break;

            case "createalbum":
                result = CreateAlbumCommand.Execute(cmdParams);
                break;

            case "addtagto":
                result = AddTagToCommand.Execute(cmdParams);
                break;

            case "makefriends":
                result = AcceptFriendCommand.Execute(cmdParams);
                break;

            case "listfriends":
                result = PrintFriendsListCommand.Execute(cmdParams);
                break;

            case "sharealbum":
                result = ShareAlbumCommand.Execute(cmdParams);
                break;

            case "uploadpicture":
                result = UploadPictureCommand.Execute(cmdParams);
                break;

            default: throw new InvalidOperationException($"Command {cmd} not valid!");
            }
            return(result);
        }
Exemple #2
0
        private string TryAcceptFriend(string command, string[] commandParams)
        {
            if (commandParams.Length != 2)
            {
                ThrowInvalidCommand(command);
            }

            var commandObj = new AcceptFriendCommand();

            return(commandObj.Execute(commandParams));
        }
        public string DispatchCommand(string[] commandParameters, Session session)
        {
            string command = commandParameters[0].ToLower();

            string result = "";

            switch (command)
            {
            case "login":
                result = LogInCommand.Execute(commandParameters, session);
                break;

            case "logout":
                result = LogoutCommand.Execute(session);
                break;

            case "exit":
                result = ExitCommand.Execute();
                break;

            case "registeruser":
                result = RegisterUserCommand.Execute(commandParameters);
                break;

            case "uploadpicture":
                result = UploadPictureCommand.Execute(commandParameters);
                break;

            case "sharealbum":
                result = ShareAlbumCommand.Execute(commandParameters);
                break;

            case "listfriends":
                result = PrintFriendsListCommand.Execute(session);
                break;

            case "acceptfriend":
                result = AcceptFriendCommand.Execute(commandParameters, session);
                break;

            case "addfriend":
                result = AddFriendCommand.Execute(commandParameters, session);
                break;

            case "addtagto":
                result = AddTagToCommand.Execute(commandParameters);
                break;

            case "createalbum":
                result = CreateAlbumCommand.Execute(commandParameters, session);
                break;

            case "addtown":
                result = AddTownCommand.Execute(commandParameters);
                break;

            case "modifyuser":
                result = ModifyUserCommand.Execute(commandParameters, session);
                break;

            case "addtag":
                result = AddTagCommand.Execute(commandParameters);
                break;

            case "deleteuser":
                result = DeleteUser.Execute(session);
                break;

            default:
                throw new InvalidOperationException($"Command {command} not valid!");
            }
            return(result);
        }
        public string DispatchCommand(string[] commandParameters, Session session)
        {
            string command = commandParameters.First();

            string[] parameters      = commandParameters.Skip(1).ToArray();
            int      parametersCount = parameters.Length;

            string output = string.Empty;

            switch (command.ToLower())
            {
            case "login":
                ValidateCommandParametersCount(command, parameters.Length, 2, true);
                output = LoginCommand.Execute(parameters, session);
                break;

            case "logout":
                ValidateCommandParametersCount(command, parameters.Length, 0, true);
                output = LogoutCommand.Execute(session);
                break;

            case "registeruser":
                ValidateCommandParametersCount(command, parameters.Length, 4, true);
                output = RegisterUserCommand.Execute(parameters, session);
                break;

            case "addtown":
                ValidateCommandParametersCount(command, parameters.Length, 2, true);
                output = AddTownCommand.Execute(parameters, session);
                break;

            case "modifyuser":
                ValidateCommandParametersCount(command, parameters.Length, 3, true);
                output = ModifyUserCommand.Execute(parameters, session);
                break;

            case "deleteuser":
                ValidateCommandParametersCount(command, parameters.Length, 1, true);
                output = DeleteUser.Execute(parameters, session);
                break;

            case "addtag":
                ValidateCommandParametersCount(command, parameters.Length, 1, true);
                output = AddTagCommand.Execute(parameters, session);
                break;

            case "createalbum":
                ValidateCommandParametersCount(command, parameters.Length, 3, false);
                output = CreateAlbumCommand.Execute(parameters, session);
                break;

            case "addtagto":
                ValidateCommandParametersCount(command, parameters.Length, 2, true);
                output = AddTagToCommand.Execute(parameters, session);
                break;

            case "makefriends":
                ValidateCommandParametersCount(command, parameters.Length, 2, true);
                output = AddFriendCommand.Execute(parameters, session);
                break;

            case "acceptfriend":
                ValidateCommandParametersCount(command, parameters.Length, 2, true);
                output = AcceptFriendCommand.Execute(parameters, session);
                break;

            case "listfriends":
                ValidateCommandParametersCount(command, parameters.Length, 1, true);
                output = PrintFriendsListCommand.Execute(parameters, session);
                break;

            case "sharealbum":
                ValidateCommandParametersCount(command, parameters.Length, 3, true);
                output = ShareAlbumCommand.Execute(parameters, session);
                break;

            case "uploadpicture":
                ValidateCommandParametersCount(command, parameters.Length, 3, true);
                output = UploadPictureCommand.Execute(parameters, session);
                break;

            case "exit":
                ValidateCommandParametersCount(command, parameters.Length, 0, true);
                output = ExitCommand.Execute();
                break;

            default:
                throw new
                      InvalidOperationException($"Command {command} not valid!");
            }

            return(output);
        }
Exemple #5
0
        public string DispatchCommand(string[] commandParameters)
        {
            string command = commandParameters[0].ToLower();
            string result  = default(string);

            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 "createalbum":
                result = CreateAlbumCommand.Execute(commandParameters);
                break;

            case "makefriends":
                result = AddFriendCommand.Execute(commandParameters);
                break;

            case "addtagto":
                result = AddTagToCommand.Execute(commandParameters);
                break;

            case "acceptfriend":
                result = AcceptFriendCommand.Execute(commandParameters);
                break;

            case "listfriends":
                result = PrintFriendsListCommand.Execute(commandParameters);
                break;

            case "sharealbum":
                result = ShareAlbumCommand.Execute(commandParameters);
                break;

            case "uploadpicture":
                result = UploadPictureCommand.Execute(commandParameters);
                break;

            case "login":
                var authenticationService = new AuthenticationService();
                var userService           = new UserService();

                var login = new LoginCommand(authenticationService, userService);
                result = login.Execute(commandParameters);
                break;

            case "logout":
                authenticationService = new AuthenticationService();
                userService           = new UserService();

                var logOut = new LogoutCommand(authenticationService, userService);
                result = logOut.Execute();
                break;

            case "exit":
                result = ExitCommand.Execute();
                break;

            default:
                throw new InvalidOperationException($"Command {command} not valid!");
            }

            return(result);
        }
        public string DispatchCommand(string[] commandParameters)
        {
            string commandName = commandParameters[0];

            var    commandArg = commandParameters.Skip(1).ToArray();
            string result     = string.Empty;

            switch (commandName)
            {
            case "RegisterUser":
                var registerUser = new RegisterUserCommand();
                result = registerUser.Execute(commandArg);
                break;

            case "AddTown":
                var addTown = new AddTownCommand();
                result = addTown.Execute(commandArg);
                break;

            case "ModifyUser":
                var modifyUser = new ModifyUserCommand();
                result = modifyUser.Execute(commandArg);
                break;

            case "DeleteUser":
                var deleteUser = new DeleteUser();
                result = deleteUser.Execute(commandArg);
                break;

            case "AddTag":
                var tag = new AddTagCommand();
                result = tag.Execute(commandArg);
                break;

            case "CreateAlbum":
                var album = new CreateAlbumCommand();
                result = album.Execute(commandArg);
                break;

            case "AddTagTo":
                var tagTo = new AddTagToCommand();
                result = tagTo.Execute(commandArg);
                break;

            case "AddFriend":
                var addFriend = new AddFriendCommand();
                result = addFriend.Execute(commandArg);
                break;

            case "AcceptFriend":
                var acceptFriend = new AcceptFriendCommand();
                result = acceptFriend.Execute(commandArg);
                break;

            case "ListFriends":
                var listFriend = new PrintFriendsListCommand();
                result = listFriend.Execute(commandArg);
                break;

            case "ShareAlbum":
                var shareAlbum = new ShareAlbumCommand();
                result = shareAlbum.Execute(commandArg);
                break;

            case "UploadPicture":
                var uploadPicture = new UploadPictureCommand();
                result = uploadPicture.Execute(commandArg);
                break;

            case "Exit":
                ExitCommand.Execute();
                break;

            case "Login":
                var login = new LoginCommand();
                result = login.Execute(commandArg);
                break;

            case "Logout":
                var logout = new LogoutCommand();
                result = logout.Execute();
                break;

            default:
                throw new InvalidOperationException($"Command {commandName} not valid!");
            }

            return(result);
        }
Exemple #7
0
        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!");
        }
Exemple #8
0
        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);
        }