public string DispatchCommand(string[] commandParameters)
        {
            string command = commandParameters[0];

            commandParameters = commandParameters.Skip(1).ToArray() `;

            switch (command)
            {
            case "RegisterUser":
                return(RegisterUserCommand.Execute(commandParameters));

            case "AddTown":
                return(AddTownCommand.Execute(commandParameters));

            case "ModifyUser":
                return(ModifyUserCommand.Execute(commandParameters));

            case "DeleteUser":
                return(DeleteUserCommand.Execute(commandParameters));

            case "AddTag":
                return(AddTagCommand.Execute(commandParameters));

            default:
                throw new InvalidOperationException($"Command {command} not valid!");
            }
        }
Ejemplo n.º 2
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);
        }
Ejemplo n.º 3
0
        public void GivenAListOfTagsToTheCreateCommandThenTheListCommandListsThemCorrectly()
        {
            var tag = MockTagStore.Create();

            var      tagParser = new TagParser((name, parent) => new Tag(tag, name, parent));
            ICommand addTag    = new AddTagCommand(tagParser);

            List <string> taxPeriods = new List <string> {
                ":tax_period:2016", ":tax_period:2017", ":tax_period:2018", ":tax_period:2019"
            };
            List <string> movieRating = new List <string> {
                ":movie:bad", ":movie:average", ":movie:good", ":movie:great"
            };

            var mockOptions = new Mock <IOptionParser>();

            addTag.Execute(taxPeriods, mockOptions.Object);
            addTag.Execute(movieRating, mockOptions.Object);

            Assert.Collection(tag.Tags,
                              item => Assert.Equal("2016", item.Name),
                              item => Assert.Equal("tax_period", item.Parent?.Name),
                              item => Assert.Equal(taxPeriods[2], item.FullName),
                              item => Assert.Equal(taxPeriods[3], item.FullName),
                              item => Assert.Equal("bad", item.Name),
                              item => Assert.Equal("movie", item.Parent?.Name),
                              item => Assert.Equal(movieRating[2], item.FullName),
                              item => Assert.Equal(movieRating[3], item.FullName)
                              );

            var      console  = new MemoryConsoleWriter();
            ICommand listTags = new ListTagsCommand(tag, console);

            listTags.Execute(Enumerable.Empty <string>(), mockOptions.Object);

            Assert.Collection(console.Lines,
                              line => Assert.Equal("Used tags: ", line),
                              line => Assert.Equal("* :tax_period:2016 (0) ", line),
                              line => Assert.Equal("* :tax_period:2017 (0) ", line),
                              line => Assert.Equal("* :tax_period:2018 (0) ", line),
                              line => Assert.Equal("* :tax_period:2019 (0) ", line),
                              line => Assert.Equal("* :movie:bad       (0) ", line),
                              line => Assert.Equal("* :movie:average   (0) ", line),
                              line => Assert.Equal("* :movie:good      (0) ", line),
                              line => Assert.Equal("* :movie:great     (0) ", line)
                              );
        }
Ejemplo n.º 4
0
        private string TryAddTag(string command, string[] commandParams)
        {
            if (commandParams.Length != 1)
            {
                ThrowInvalidCommand(command);
            }

            var commandObj = new AddTagCommand();

            return(commandObj.Execute(commandParams));
        }
        public string DispatchCommand(string[] commandParameters)
        {
            string commandToExecute = commandParameters[0].ToLower();
            string result           = null;

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

            case "exit":
                break;

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

            return(result);
        }
Ejemplo n.º 6
0
        public string DispatchCommand(string[] commandParameters)
        {
            var userService     = new UserService();
            var townService     = new TownService();
            var tagService      = new TagService();
            var albumService    = new AlbumService();
            var pictureService  = new PictureService();
            var securityService = new SecurityService();

            string command = commandParameters[0];

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

            switch (command)
            {
            case "RegisterUser":
                var registerUser = new RegisterUserCommand(userService);
                result = registerUser.Execute(commandParameters);
                break;

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

            case "ModifyUser":
                var modifyUser = new ModifyUserCommand(userService, townService);
                result = modifyUser.Execute(commandParameters);
                break;

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

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

            case "AddTag":
                var addTag = new AddTagCommand(tagService);
                result = addTag.Execute(commandParameters);
                break;

            case "CreateAlbum":
                var createAlbum = new CreateAlbumCommand(albumService, userService, tagService);
                result = createAlbum.Execute(commandParameters);
                break;

            case "AddTagTo":
                var addTagTo = new AddTagToCommand(tagService, albumService);
                result = addTagTo.Execute(commandParameters);
                break;

            case "MakeFriends":
                var makeFriends = new MakeFriendsCommand(userService);
                result = makeFriends.Execute(commandParameters);
                break;

            case "ListFriends":
                var listFriends = new ListFriendsCommand(userService);
                result = listFriends.Execute(commandParameters);
                break;

            case "ShareAlbum":
                var shareAlbum = new ShareAlbumCommand(albumService, userService);
                result = shareAlbum.Execute(commandParameters);
                break;

            case "UploadPicture":
                var uploadPicture = new UploadPictureCommand(pictureService, albumService);
                result = uploadPicture.Execute(commandParameters);
                break;

            case "Login":
                var loginCommand = new LoginCommand(securityService);
                result = loginCommand.Execute(commandParameters);
                break;

            case "Logout":
                var logoutCommand = new LogoutCommand(securityService);
                result = logoutCommand.Execute();
                break;
            }
            return(result);
        }
Ejemplo n.º 7
0
        public string DispatchCommand(string[] commandParameters)
        {
            PictureService pictureService = new PictureService();
            AlbumService   albumService   = new AlbumService();
            UserService    userService    = new UserService();
            TownService    townService    = new TownService();
            TagService     tagService     = new TagService();

            string commandName = commandParameters[0];

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

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

            case "AddTown":
                AddTownCommand addTown = new AddTownCommand(townService);
                result = addTown.Execute(commandParameters);
                break;

            case "ModifyUser":
                ModifyUserCommand modifyUser = new ModifyUserCommand(userService, townService);
                result = modifyUser.Execute(commandParameters);
                break;

            case "DeleteUser":
                DeleteUserCommand deleteUser = new DeleteUserCommand(userService);
                result = deleteUser.Execute(commandParameters);
                break;

            case "AddTag":
                AddTagCommand addTag = new AddTagCommand(tagService);
                result = addTag.Execute(commandParameters);
                break;

            case "CreateAlbum":
                CreateAlbumCommand createAlbum = new CreateAlbumCommand(albumService, userService, tagService);
                result = createAlbum.Execute(commandParameters);
                break;

            case "AddTagTo":
                AddTagToCommand addTagTo = new AddTagToCommand(albumService, tagService);
                result = addTagTo.Execute(commandParameters);
                break;

            case "MakeFriends":
                MakeFriendsCommand makeFriends = new MakeFriendsCommand(userService);
                result = makeFriends.Execute(commandParameters);
                break;

            case "ListFriends":
                ListFriendsCommand listFriends = new ListFriendsCommand(userService);
                result = listFriends.Execute(commandParameters);
                break;

            case "ShareAlbum":
                ShareAlbumCommand shareAlbum = new ShareAlbumCommand(albumService, userService);
                result = shareAlbum.Execute(commandParameters);
                break;

            case "UploadPicture":
                UploadPictureCommand uploadPicture = new UploadPictureCommand(albumService, pictureService);
                result = uploadPicture.Execute(commandParameters);
                break;

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

            case "Login":
                LoginUserCommand loginUser = new LoginUserCommand();
                result = loginUser.Execute(commandParameters);
                break;

            case "Logout":
                LogoutUserCommand logoutUser = new LogoutUserCommand();
                result = logoutUser.Execute(commandParameters);
                break;

            default:
                result = $"Command {commandName} not valid!";
                break;
            }

            return(result);
        }
Ejemplo n.º 8
0
        public string DispatchCommand(string[] commandParameters)
        {
            string commandName = commandParameters[0];

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

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

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

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

            case "DeleteUser":
                DeleteUserCommand deleteUser = new DeleteUserCommand();
                result = deleteUser.Execute(commandParameters);
                break;

            case "AddTag":
                AddTagCommand addTag = new AddTagCommand();
                result = addTag.Execute(commandParameters);
                break;

            case "CreateAlbum":
                CreateAlbumCommand createAlbum = new CreateAlbumCommand();
                result = createAlbum.Execute(commandParameters);
                break;

            case "AddTagTo":
                AddTagToCommand addTagTo = new AddTagToCommand();
                result = addTagTo.Execute(commandParameters);
                break;

            case "MakeFriends":
                MakeFriendsCommand makeFriend = new MakeFriendsCommand();
                result = makeFriend.Execute(commandParameters);
                break;

            case "ListFriends":
                PrintFriendsListCommand listFriends = new PrintFriendsListCommand();
                result = listFriends.Execute(commandParameters);
                break;

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

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

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

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

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

            default:
                Console.WriteLine($"Command {commandName} not valid!");
                break;
            }

            return(result);
        }
Ejemplo n.º 9
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);
        }
        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);
        }
Ejemplo n.º 11
0
        public string DispatchCommand(string[] commandParameters)
        {
            string commandName = commandParameters[0];

            commandParameters = commandParameters.Skip(1).ToArray(); // skipping commandName

            string result = string.Empty;

            UserService    userService    = new UserService();
            TownService    townService    = new TownService();
            TagService     tagService     = new TagService();
            AlbumService   albumService   = new AlbumService();
            PictureService pictureService = new PictureService();

            switch (commandName)
            {
            // 1. Photo Share System
            case "RegisterUser":
                ValidateInput.CheckExactInputArgsCount(commandName, commandParameters.Count(), 4);
                RegisterUserCommand registerUser = new RegisterUserCommand(userService);
                result = registerUser.Execute(commandParameters);
                break;

            case "AddTown":
                ValidateInput.CheckExactInputArgsCount(commandName, commandParameters.Count(), 2);
                AddTownCommand addTown = new AddTownCommand(townService);
                result = addTown.Execute(commandParameters);
                break;

            case "ModifyUser":
                ValidateInput.CheckExactInputArgsCount(commandName, commandParameters.Count(), 3);
                ModifyUserCommand modifyUser = new ModifyUserCommand(userService, townService);
                result = modifyUser.Execute(commandParameters);
                break;

            case "DeleteUser":
                ValidateInput.CheckExactInputArgsCount(commandName, commandParameters.Count(), 1);
                DeleteUserCommand deleteUser = new DeleteUserCommand(userService);
                result = deleteUser.Execute(commandParameters);
                break;

            case "AddTag":
                ValidateInput.CheckExactInputArgsCount(commandName, commandParameters.Count(), 1);
                AddTagCommand addTag = new AddTagCommand(tagService);
                result = addTag.Execute(commandParameters);
                break;

            case "CreateAlbum":
                ValidateInput.CheckMinInputArgsCount(commandName, commandParameters.Count(), 4);
                CreateAlbumCommand createAlbum = new CreateAlbumCommand(userService, albumService, tagService);
                result = createAlbum.Execute(commandParameters);
                break;

            case "AddTagTo":
                ValidateInput.CheckExactInputArgsCount(commandName, commandParameters.Count(), 2);
                AddTagToCommand addTagTo = new AddTagToCommand(albumService, tagService);
                result = addTagTo.Execute(commandParameters);
                break;

            case "MakeFriends":
                ValidateInput.CheckExactInputArgsCount(commandName, commandParameters.Count(), 2);
                MakeFriendsCommand makeFriends = new MakeFriendsCommand(userService);
                result = makeFriends.Execute(commandParameters);
                break;

            case "ListFriends":
                ValidateInput.CheckExactInputArgsCount(commandName, commandParameters.Count(), 1);
                ListFriendsCommand listFriends = new ListFriendsCommand(userService);
                result = listFriends.Execute(commandParameters);
                break;

            case "ShareAlbum":
                ValidateInput.CheckExactInputArgsCount(commandName, commandParameters.Count(), 3);
                ShareAlbumCommand shareAlbum = new ShareAlbumCommand(userService, albumService);
                result = shareAlbum.Execute(commandParameters);
                break;

            case "UploadPicture":
                ValidateInput.CheckExactInputArgsCount(commandName, commandParameters.Count(), 3);
                UploadPictureCommand uploadPicture = new UploadPictureCommand(albumService, pictureService);
                result = uploadPicture.Execute(commandParameters);
                break;

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

            // 2. Extend Photo Share System
            case "Login":
                ValidateInput.CheckExactInputArgsCount(commandName, commandParameters.Count(), 2);
                LoginCommand login = new LoginCommand(userService);
                result = login.Execute(commandParameters);
                break;

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

            // 1. Photo Share System
            default:
                throw new InvalidOperationException($"Command <{commandName}> not valid!");
            }

            return(result);
        }
Ejemplo n.º 12
0
        public string DispatchCommand(string[] commandParameters)
        {
            string commandName = commandParameters[0];

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

            switch (commandName)
            {
            case "RegisterUser":
                if (commandParameters.Count() != 4)
                {
                    throw new InvalidOperationException($"Command {commandName} not valid!");
                }
                RegisterUserCommand registerUser = new RegisterUserCommand(new UserService());
                result = registerUser.Execute(commandParameters);
                break;

            case "AddTown":
                if (commandParameters.Count() != 2)
                {
                    throw new InvalidOperationException($"Command {commandName} not valid!");
                }
                AddTownCommand addTown = new AddTownCommand(new TownService());
                result = addTown.Execute(commandParameters);
                break;

            case "ModifyUser":
                if (commandParameters.Count() != 3)
                {
                    throw new InvalidOperationException($"Command {commandName} not valid!");
                }
                ModifyUserCommand modifyUser = new ModifyUserCommand(new UserService(), new TownService());
                result = modifyUser.Execute(commandParameters);
                break;

            case "DeleteUser":
                if (commandParameters.Count() != 1)
                {
                    throw new InvalidOperationException($"Command {commandName} not valid!");
                }
                DeleteUserCommand deleteUser = new DeleteUserCommand(new UserService());
                result = deleteUser.Execute(commandParameters);
                break;

            case "AddTag":
                if (commandParameters.Count() != 1)
                {
                    throw new InvalidOperationException($"Command {commandName} not valid!");
                }
                AddTagCommand addTag = new AddTagCommand(new TagService());
                result = addTag.Execute(commandParameters);
                break;

            case "CreateAlbum":
                if (commandParameters.Count() < 4)
                {
                    throw new InvalidOperationException($"Command {commandName} not valid!");
                }
                CreateAlbumCommand createAlbum = new CreateAlbumCommand(new AlbumService(), new UserService(), new TagService());
                result = createAlbum.Execute(commandParameters);
                break;

            case "AddTagTo":
                if (commandParameters.Count() != 2)
                {
                    throw new InvalidOperationException($"Command {commandName} not valid!");
                }
                AddTagToCommand addTagTo = new AddTagToCommand(new TagService(), new AlbumService());
                result = addTagTo.Execute(commandParameters);
                break;

            case "MakeFriends":
                if (commandParameters.Count() != 2)
                {
                    throw new InvalidOperationException($"Command {commandName} not valid!");
                }
                MakeFriendsCommand makeFriends = new MakeFriendsCommand(new UserService());
                result = makeFriends.Execute(commandParameters);
                break;

            case "ListFriends":
                if (commandParameters.Count() != 1)
                {
                    throw new InvalidOperationException($"Command {commandName} not valid!");
                }
                PrintFriendsListCommand printFriends = new PrintFriendsListCommand(new UserService());
                result = printFriends.Execute(commandParameters);
                break;

            case "ShareAlbum":
                if (commandParameters.Count() != 3)
                {
                    throw new InvalidOperationException($"Command {commandName} not valid!");
                }
                ShareAlbumCommand shareAlbum = new ShareAlbumCommand(new UserService(), new AlbumService());
                result = shareAlbum.Execute(commandParameters);
                break;

            case "UploadPicture":
                if (commandParameters.Count() != 3)
                {
                    throw new InvalidOperationException($"Command {commandName} not valid!");
                }
                UploadPictureCommand uploadPicture = new UploadPictureCommand(new AlbumService(), new PictureService());
                result = uploadPicture.Execute(commandParameters);
                break;

            case "Login":
                if (commandParameters.Count() != 2)
                {
                    throw new InvalidOperationException($"Command {commandName} not valid!");
                }
                LoginCommand loginCommand = new LoginCommand(new AuthenticationService(), new UserService());
                result = loginCommand.Execute(commandParameters);
                break;

            case "Logout":
                if (commandParameters.Count() > 0)
                {
                    throw new InvalidOperationException($"Command {commandName} not valid!");
                }
                LogoutCommand logoutCommand = new LogoutCommand(new AuthenticationService(), new UserService());
                result = logoutCommand.Execute();
                break;

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

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

            return(result);
        }
Ejemplo n.º 13
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!");
        }
Ejemplo n.º 14
0
        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);
        }
Ejemplo n.º 15
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, 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);
        }
Ejemplo n.º 17
0
        public string DispatchCommand(string[] commandParameters)
        {
            string result;

            switch (commandParameters[0])
            {
            case "RegisterUser":        ////
                if (commandParameters.Length != 5)
                {
                    goto default;
                }
                AccessAsLoggedOut();
                Commands.RegisterUserCommand registerUser = new RegisterUserCommand();
                result = registerUser.Execute(commandParameters.Skip(1).ToArray());
                break;

            case "AddTown":        ////
                if (commandParameters.Length != 3)
                {
                    goto default;
                }
                AccessAsLoggedIn(commandParameters);
                Commands.AddTownCommand addTown = new AddTownCommand();
                result = addTown.Execute(commandParameters.Skip(1).ToArray());
                break;

            case "ModifyUser":        ////
                if (commandParameters.Length != 3)
                {
                    goto default;
                }
                AccessAsLoggedIn(commandParameters);
                Commands.ModifyUserCommand modifyUser = new ModifyUserCommand();
                result = modifyUser.Execute(commandParameters.Skip(1).ToArray());
                break;

            case "DeleteUser":        ////
                if (commandParameters.Length != 1)
                {
                    goto default;
                }
                AccessAsLoggedIn(commandParameters);
                Commands.DeleteUserCommand deleteUser = new DeleteUserCommand();
                result = deleteUser.Execute();
                break;

            case "AddTag":        ////
                if (commandParameters.Length != 2)
                {
                    goto default;
                }
                AccessAsLoggedIn(commandParameters);
                Commands.AddTagCommand addTag = new AddTagCommand();
                result = addTag.Execute(commandParameters.Skip(1).ToArray());
                break;

            case "CreateAlbum":        ////
                if (commandParameters.Length < 2)
                {
                    goto default;
                }
                AccessAsLoggedIn(commandParameters);
                Commands.CreateAlbumCommand createAlbum = new CreateAlbumCommand();
                result = createAlbum.Execute(commandParameters.Skip(1).ToArray());
                break;

            case "AddTagTo":        ////
                if (commandParameters.Length != 3)
                {
                    goto default;
                }
                AccessAsLoggedIn(commandParameters);
                Commands.AddTagToCommand addTagTo = new AddTagToCommand();
                result = addTagTo.Execute(commandParameters.Skip(1).ToArray());
                break;

            case "MakeFriends":        ////
                if (commandParameters.Length != 2)
                {
                    goto default;
                }
                AccessAsLoggedIn(commandParameters);
                Commands.MakeFriendsCommand makeFriends = new MakeFriendsCommand();
                result = makeFriends.Execute(commandParameters.Skip(1).ToArray());
                break;

            case "ListFriends":        ////
                if (commandParameters.Length != 2)
                {
                    goto default;
                }
                // both users can
                Commands.PrintFriendsListCommand printFriends = new PrintFriendsListCommand();
                result = printFriends.Execute(commandParameters.Skip(1).ToArray());
                break;

            case "ShareAlbum":        ////
                if (commandParameters.Length != 3)
                {
                    goto default;
                }
                AccessAsLoggedIn(commandParameters);
                Commands.ShareAlbumCommand shareAlbum = new ShareAlbumCommand();
                result = shareAlbum.Execute(commandParameters.Skip(1).ToArray());
                break;

            case "UploadPicture":        ////
                if (commandParameters.Length != 4)
                {
                    goto default;
                }
                AccessAsLoggedIn(commandParameters);
                Commands.UploadPictureCommand uppCommand = new UploadPictureCommand();
                result = uppCommand.Execute(commandParameters.Skip(1).ToArray());
                break;

            case "Exit":        ////
                if (commandParameters.Length != 1)
                {
                    goto default;
                }
                // both users can
                Commands.ExitCommand exit = new ExitCommand();
                result = exit.Execute();
                break;

            case "Login":        ////
                if (commandParameters.Length != 3)
                {
                    goto default;
                }
                AccessAsLoggedOut();
                Commands.LoginCommand login = new LoginCommand();
                result = login.Execute(commandParameters.Skip(1).ToArray());
                break;

            case "Logout":        ///
                if (commandParameters.Length != 1)
                {
                    goto default;
                }
                AccessAsLoggedIn(commandParameters);
                Commands.LogoutCommand logout = new LogoutCommand();
                result = logout.Execute();
                break;

            default:
                throw new InvalidOperationException($"Command {commandParameters[0]} not valid!");
            }

            return(result);
        }