public async Task ExecuteAsync_MultiPartRouteWithBodyFromFile_VerifyResponse()
        {
            string filePath     = "someFilePath.txt";
            string fileContents = "This is a test response from a PUT: \"Test Put Body From File\"";

            ArrangeInputs(commandText: $"PUT --file " + filePath,
                          baseAddress: _baseAddress,
                          path: _testPath,
                          urlsWithResponse: _urlsWithResponse,
                          out MockedShellState shellState,
                          out HttpState httpState,
                          out ICoreParseResult parseResult,
                          out MockedFileSystem fileSystem,
                          out IPreferences preferences,
                          readBodyFromFile: true,
                          fileContents: fileContents);

            fileSystem.AddFile(filePath, "Test Put Body From File");

            PutCommand putCommand = new PutCommand(fileSystem, preferences);
            await putCommand.ExecuteAsync(shellState, httpState, parseResult, CancellationToken.None);

            List <string> result = shellState.Output;

            Assert.Equal(2, result.Count);
            Assert.Contains("HTTP/1.1 200 OK", result);
            Assert.Contains(fileContents, result);
        }
Exemple #2
0
 public CustomerController(PostCommand <Customer> command, GetAllCommand <Customer> getCommand,
                           PutCommand <Customer> putCommand)
 {
     this.postCommand   = command;
     this.putCommand    = putCommand;
     this.getAllCommand = getCommand;
 }
Exemple #3
0
 protected void GetInfo(object obj, EventArgs args)
 {
     if (_playername == "")
     {
         _playername = playerText.Text;
         _player.AddIdentifier(_playername);
         playerText.Text = "";
         playerText.Hide();
         descText.Show();
         TextArea.Buffer.Text = "Tell me something about yourself";
     }
     else if (!IsEmpty(descText.Text) && !IsEmpty(_playername))
     {
         _desc = descText.Text;
         _player.Description = _desc;
         descText.Text       = "";
         descText.Hide();
         commandText.Show();
         TextArea.Buffer.Text = "Enter commands or type quit to exit";
     }
     else
     {
         string           command       = commandText.Text.ToLower();
         char             delimiterChar = ' ';
         string[]         cmd           = command.Split(delimiterChar);
         LookCommand      look          = new LookCommand(new string[] { "look" });
         MoveCommand      move          = new MoveCommand(new string[] { "move", "go", "head", "leave" });
         PutCommand       put           = new PutCommand(new string[] { "put", "drop" });
         TakeCommand      take          = new TakeCommand(new string[] { "pickup", "take" });
         CommandProcessor cp            = new CommandProcessor(new string[] { }, new Command[] { look, move, put, take });
         TextArea.Buffer.Text = cp.Execute(_player, cmd);
     }
 }
        public void Handle_WithPutCommand_CallsPutAPI()
        {
            const string testFilePath = "TestFilePath";
            const string testSrcFile  = "TestSrcFile";

            // Arrange
            var mockClientProtocol = new Mock <IRestClientProtocol>();
            var locatedBlock       = new LocatedBlock()
            {
                Locations = new DataNodeId[] { new DataNodeId {
                                                   IPAddress = "http://localhost"
                                               } }
            };

            mockClientProtocol.Setup(x => x.AddBlock(It.IsAny <string>())).Returns(locatedBlock);
            var stubDataTransferProtocol = new Mock <IRestDataTransferProtocol>();
            var sut            = new PutCommandHandler(mockClientProtocol.Object, stubDataTransferProtocol.Object);
            var stubPutCommand = new PutCommand()
            {
                FilePath = testFilePath, SrcFile = testSrcFile
            };

            // Act
            sut.Handle(stubPutCommand);

            // Assert
            mockClientProtocol.Verify(x => x.Create(testSrcFile, testFilePath));
        }
        public async Task CreateBatchAndUpdateTimeouts(RavenBatch batch)
        {
            var insertCommand = new PutCommand
            {
                Id           = $"{RavenConstants.BatchPrefix}/{batch.Number}",
                Type         = "PUT",
                ChangeVector = null,
                Document     = batch
            };

            var timeoutUpdateCommands = batch.TimeoutIds.Select(timeoutId => new PatchCommand
            {
                Id           = timeoutId,
                Type         = "PATCH",
                ChangeVector = null,
                Patch        = new Patch()
                {
                    Script = $"this.OwningTimeoutManager = '{RavenConstants.MigrationOngoingPrefix}' + this.OwningTimeoutManager;",
                    Values = new { }
                }
            }).ToList();

            var commands = new List <object>
            {
                insertCommand
            };

            commands.AddRange(timeoutUpdateCommands);

            await PostToBulkDocs(commands);
        }
Exemple #6
0
 public AccountController(PostCommand <Account> command, GetAllCommand <Account> getAllCommand,
                          GetStringCommand <Account> getStringCommand, DeleteCommand deleteCommand, PutCommand <Account> putCommand)
 {
     this.postCommand      = command;
     this.getAllCommand    = getAllCommand;
     this.getStringCommand = getStringCommand;
     this.deleteCommand    = deleteCommand;
     this.putCommand       = putCommand;
 }
        public async Task ExecuteAsync_WithNoBasePath_VerifyError()
        {
            ArrangeInputs(commandText: "PUT",
                          baseAddress: null,
                          path: null,
                          urlsWithResponse: null,
                          out MockedShellState shellState,
                          out HttpState httpState,
                          out ICoreParseResult parseResult,
                          out MockedFileSystem fileSystem,
                          out IPreferences preferences);

            string expectedErrorMessage = Strings.Error_NoBasePath.SetColor(httpState.ErrorColor);

            PutCommand putCommand = new PutCommand(fileSystem, preferences);
            await putCommand.ExecuteAsync(shellState, httpState, parseResult, CancellationToken.None);

            Assert.Equal(expectedErrorMessage, shellState.ErrorMessage);
        }
Exemple #8
0
        public async Task <IActionResult> Update(int id, [FromBody] PutCommand model)
        {
            var produto = await _prodRepository.GetAsync(id);

            if (produto == null)
            {
                ModelState.AddModelError("Id", "Produto não encontrado");
            }

            if (!ModelState.IsValid)
            {
                return(BadRequest(ModelState));
            }

            produto.Atualizar(model.Nome, model.PrecoUnitario, model.CategoriaId, model.QtdeEmEstoque);

            _prodRepository.Update(produto);
            await _uow.CommitAsync();

            return(NoContent());
        }
        public async Task ExecuteAsync_MultiPartRouteWithInlineContent_VerifyResponse()
        {
            ArrangeInputs(commandText: "PUT --content \"Test Put Body\"",
                          baseAddress: _baseAddress,
                          path: _testPath,
                          urlsWithResponse: _urlsWithResponse,
                          out MockedShellState shellState,
                          out HttpState httpState,
                          out ICoreParseResult parseResult,
                          out MockedFileSystem fileSystem,
                          out IPreferences preferences);

            PutCommand putCommand = new PutCommand(fileSystem, preferences);
            await putCommand.ExecuteAsync(shellState, httpState, parseResult, CancellationToken.None);

            string        expectedResponse = "This is a test response from a PUT: \"Test Put Body\"";
            List <string> result           = shellState.Output;

            Assert.Equal(2, result.Count);
            Assert.Contains("HTTP/1.1 200 OK", result);
            Assert.Contains(expectedResponse, result);
        }
        public async Task <IActionResult> Update(int id, [FromBody] PutCommand model)
        {
            var categoria = await _catRepository.GetAsync(id);

            if (categoria == null)
            {
                ModelState.AddModelError("Id", "Categoria não encontrada");
            }

            if (!ModelState.IsValid)
            {
                return(BadRequest(ModelState));
            }

            categoria.Atualizar(model.Nome);

            _catRepository.Update(categoria);
            await _uow.CommitAsync();


            return(NoContent());
        }
Exemple #11
0
        internal static Command Parse(string input)
        {
            var splittedCmd = input.Split(new[] { ' ' }, StringSplitOptions.RemoveEmptyEntries);

            if (splittedCmd.Length == 0)
            {
                return(new EmptyCommand());
            }

            var cmdArgs = new string[splittedCmd.Length - 1];

            Array.Copy(splittedCmd, 1, cmdArgs, 0, cmdArgs.Length);

            Command cmd = null;

            switch (splittedCmd[0].ToLower())
            {
            case "dir":
                cmd = new DirCommand();
                break;

            case "post":
                cmd = new PostCommand();
                break;

            case "put":
                cmd = new PutCommand();
                break;

            case "get":
                cmd = new GetCommand();
                break;

            case "delete":
                cmd = new DeleteCommand();
                break;

            case "connect":
                break;

            case "disconnect":
                break;

            case "capturestatson":
                break;

            case "capturestatsoff":
                break;

            case "help":
                cmd = new HelpCommand();
                break;

            case "exit":
                cmd = new ExitCommand();
                break;

            case "ping":
                cmd = new PingCommand();
                break;

            default:
                cmd = new UnknownCommand(splittedCmd[0]);
                break;
            }
            cmd.Parse(cmdArgs);
            return(cmd);
        }
        static void Main(string[] args)
        {
            Console.WriteLine("Welcome to Swin-Adventure!");
            Console.WriteLine();

            Console.WriteLine("This is the first version of the game that is created by me. Enjoy the adventure in the game world!");
            Console.WriteLine();
            Console.WriteLine();
            Console.WriteLine("What is your name?");
            string name = Console.ReadLine();

            Console.WriteLine("How can you describe yourself(for example, a mighty programmer)?");
            string description = Console.ReadLine();

            Console.WriteLine("Let's begin your adventure today!");
            Player newPlayer   = new Player(name, description);
            bool   StayingOpen = true;

            // adding items and bag
            Item Itm1 = new Item(new string[] { "golden", "ring" }, "ring", "This is a golden ring for you");
            Item Itm2 = new Item(new string[] { "yellow", "small", "box" }, "box", "This is a small yellow box for you");
            Item Itm3 = new Item(new string[] { "purple", "ball" }, "ball", "That is a small and purple ball");
            Item Itm4 = new Item(new string[] { "green", "table" }, "table", "This is a dining table. Be careful with it!");
            Item Itm5 = new Item(new string[] { "orange" }, "orange", "This is an orange for you.");
            Bag  Bag1 = new Bag(new string[] { "red", "bag" }, "bag", "This is a large and red bag");

            // adding locations
            Location Loc1 = new Location("coffee house", " where you could go to coffee house each day");
            Location Loc2 = new Location("palace", "where the duke worked and lived");
            Location Loc3 = new Location("old fort", "where we could see the port");
            Location Loc4 = new Location("small house", "where an old family lives");
            Location Loc5 = new Location("museum", "which is quite niche");
            Location Loc6 = new Location("stable", "where people raise their finest horses");


            // adding paths
            Path path1 = new Path(new string[] { "north" }, "a trail", " which is where people go every day", Loc1, Loc2);
            Path path2 = new Path(new string[] { "west" }, "main road", " where traders move and go", Loc1, Loc6);
            Path path3 = new Path(new string[] { "east" }, "river bank", " where the weather is quite sunny.", Loc1, Loc3);
            Path path4 = new Path(new string[] { "south" }, "small grove", " near a tiny lake", Loc1, Loc4);
            Path path5 = new Path(new string[] { "northwest" }, "a creek", " where a plan was laid out", Loc1, Loc5);
            Path path6 = new Path(new string[] { "southwest" }, "big street", "near the center of the city", Loc2, Loc3);
            Path path7 = new Path(new string[] { "northeast" }, "a corridor", "near a forest", Loc2, Loc4);
            Path path8 = new Path(new string[] { "southeast" }, "a bridge", "through the great river", Loc2, Loc5);
            Path path9 = new Path(new string[] { "gate" }, "new gate", "leads to stable", Loc2, Loc6);

            //add path to locations.
            Loc1.AddPath(path1);
            Loc1.AddPath(path2);
            Loc1.AddPath(path3);
            Loc1.AddPath(path4);
            Loc1.AddPath(path5);
            Loc2.AddPath(path6);
            Loc2.AddPath(path7);
            Loc2.AddPath(path8);
            Loc2.AddPath(path9);

            Loc1.Inventory.Put(Itm4);
            newPlayer.Location = Loc1;
            newPlayer.Inventory.Put(Itm1);
            newPlayer.Inventory.Put(Itm2);
            newPlayer.Inventory.Put(Itm5);
            newPlayer.Inventory.Put(Bag1);
            Bag1.Inventory.Put(Itm3);

            //handling Command Processor.
            CommandProcessor newCommand = new CommandProcessor();
            TakeCommand      Take       = new TakeCommand();

            newCommand.AddCommand(Take);
            LookCommand Look = new LookCommand();

            newCommand.AddCommand(Look);
            MoveCommand Move = new MoveCommand();

            newCommand.AddCommand(Move);
            PutCommand Put = new PutCommand();

            newCommand.AddCommand(Put);



            while (StayingOpen)
            {
                Console.WriteLine("Please enter command:");
                string   _input  = Console.ReadLine();
                string[] Command = _input.Split();// get help from Charlotte Pierce in HelpDesk.

                if (Command[0] == "quit")
                {
                    Console.WriteLine("Bye.");
                    Thread.Sleep(2000);
                    StayingOpen = false;
                }
                else
                {
                    Console.WriteLine(newCommand.Execute(newPlayer, Command));
                }
            }
        }
Exemple #13
0
        public WebDAVListener(HttpListener server, string path)
        {
            this.HttpServer = server;

            OptionsCommand optionsCommand = new OptionsCommand();
            optionsCommand.Start(this, path);
            commands.Add(optionsCommand);

            PropFindCommand propfindCommand = new PropFindCommand();
            propfindCommand.Start(this, path);
            commands.Add(propfindCommand);

            LockCommand lockCommand = new LockCommand();
            lockCommand.Start(this, path);
            commands.Add(lockCommand);

            UnlockCommand unlockCommand = new UnlockCommand();
            unlockCommand.Start(this, path);
            commands.Add(unlockCommand);

            MkcolCommand mkcolCommand = new MkcolCommand();
            mkcolCommand.Start(this, path);
            commands.Add(mkcolCommand);

            MoveCommand moveCommand = new MoveCommand();
            moveCommand.Start(this, path);
            commands.Add(moveCommand);

            GetCommand getCommand = new GetCommand();
            getCommand.Start(this, path);
            commands.Add(getCommand);

            PutCommand putCommand = new PutCommand();
            putCommand.Start(this, path);
            commands.Add(putCommand);

            DeleteCommand deleteCommand = new DeleteCommand();
            deleteCommand.Start(this, path);
            commands.Add(deleteCommand);

            CopyCommand copyCommand = new CopyCommand();
            copyCommand.Start(this, path);
            commands.Add(copyCommand);

            PropPatchCommand proppatchCommand = new PropPatchCommand();
            proppatchCommand.Start(this, path);
            commands.Add(proppatchCommand);
        }
        public void GenerateCodeForInstruction(CodeLine line)
        {
            if (InstructionHelper.IsMoveInstruction(line.instruction))
            {
                var command = new MoveCommand(InstructionHelper.GetInstructionDirection(line.instruction), currentCodeLineNumber + 1);
                commandToCodeLineMapping.Add(command, line);
                allCommands.Add(command);
            }
            if (InstructionHelper.IsPutInstruction(line.instruction))
            {
                var command = new PutCommand(currentCodeLineNumber + 1);
                commandToCodeLineMapping.Add(command, line);
                allCommands.Add(command);
            }
            if (InstructionHelper.IsPickInstruction(line.instruction))
            {
                var command = new PickCommand(currentCodeLineNumber + 1);
                commandToCodeLineMapping.Add(command, line);
                allCommands.Add(command);
            }
            if (InstructionHelper.IsJumpInstruction(line.instruction))
            {
                ICommand command;

                if (InstructionHelper.IsJumpInstructionLabel(line.instruction))
                {
                    command = new JumpCommand(currentCodeLineNumber + 1);
                    allCommands.Add(command);
                }
                else
                {
                    //this is being set in code later - otherwise forward jumps will not work - see RepairJumps for reference.
                    command = new JumpCommand(currentCodeLineNumber + 1);
                    allCommands.Add(command);
                }
                commandToCodeLineMapping.Add(command, line);
            }

            if (InstructionHelper.IsIfInstruction(line.instruction))
            {
                int trueLineNumber = currentCodeLineNumber + 1;
                int elseLineNumber = currentCodeLineNumber + line.TotalChildrenCount + 1;
                var command        = new IfCommand(trueLineNumber, elseLineNumber, GetConditions(line), GetLogicalOperators(line));
                allCommands.Add(command);
                commandToCodeLineMapping.Add(command, line);
                currentCodeLineNumber++;
                foreach (var child in line.children)
                {
                    GenerateCodeForInstruction(child);
                }
                command.NextCommandId = currentCodeLineNumber;
                currentCodeLineNumber--; //this may seem wrong but actually it is not
            }

            if (InstructionHelper.IsWhileInstruction(line.instruction))
            {
                int trueLineNumber  = currentCodeLineNumber + 1;
                int falseLineNumber = currentCodeLineNumber + line.TotalChildrenCount + 1;
                var command         = new WhileCommand(trueLineNumber, falseLineNumber, GetConditions(line), GetLogicalOperators(line));
                allCommands.Add(command);
                commandToCodeLineMapping.Add(command, line);
                currentCodeLineNumber++;
                foreach (var child in line.children)
                {
                    GenerateCodeForInstruction(child);
                }
                var loopJumpCommand = new JumpCommand(trueLineNumber - 1);
                commandToCodeLineMapping.Add(loopJumpCommand, null);
                command.NextCommandId = currentCodeLineNumber + 1;
                allCommands.Add(loopJumpCommand);
            }

            if (InstructionHelper.IsRepeatInstruction(line.instruction))
            {
                int trueLineNumber  = currentCodeLineNumber + 1;
                int falseLineNumber = currentCodeLineNumber + line.TotalChildrenCount + 1;
                var command         = new RepeatCommand(trueLineNumber, falseLineNumber, InstructionHelper.GetRepeatTimes(line.instruction));
                allCommands.Add(command);
                commandToCodeLineMapping.Add(command, line);
                currentCodeLineNumber++;
                foreach (var child in line.children)
                {
                    GenerateCodeForInstruction(child);
                }
                var loopJumpCommand = new JumpCommand(trueLineNumber - 1);
                commandToCodeLineMapping.Add(loopJumpCommand, null);
                command.NextCommandId = currentCodeLineNumber;
                allCommands.Add(loopJumpCommand);
            }

            currentCodeLineNumber++;
        }
Exemple #15
0
        public void Execute(Message msg, IMessageSenderService sender, IBot bot)
        {
            if (Main.Api.Users.IsBanned(msg))
            {
                return;
            }

            if (!Main.Api.Users.CheckUser(msg))
            {
                var kb2 = new KeyboardBuilder(bot);
                kb2.AddButton("➕ Зарегистрироваться", "start");
                sender.Text("❌ Вы не зарегистрированы, нажмите на кнопку ниже, чтобы начать", msg.ChatId, kb2.Build());
                return;
            }

            var user    = Main.Api.Users.GetUser(msg);
            var command = UsersCommandHelper.GetHelper().Get(user.Id);

            //TODO: написать с использованием команд-менеджера.
            var text = string.Empty;

            if (command == "")
            {
                if (msg.ChatId > 2000000000)
                {
                    return;
                }
                sender.Text("❌ Неизвестная команда", msg.ChatId);
                return;
            }
            else if (command == "putrawmoney")
            {
                long count;
                try
                {
                    count = long.Parse(msg.Text);
                    text  = PutCommand.PutMoney(user, count);
                }
                catch
                {
                    text = "❌ Вы ввели неверное число. Попробуйте ещё раз.";
                }
            }
            else if (command == "withdrawmoney")
            {
                long count;
                try
                {
                    count = long.Parse(msg.Text);
                    text  = WithdrawCommand.Withdraw(user, count);
                }
                catch
                {
                    text = "❌ Вы ввели неверное число. Попробуйте ещё раз.";
                }
            }
            else if (command == "exchangedonate")
            {
                long count;
                try
                {
                    count = long.Parse(msg.Text);
                    text  = ExchangeDonateCommand.Exchange(msg, count);
                }catch
                {
                    text = "❌ Вы ввели неверное число. Попробуйте ещё раз.";
                }
            }
            else if (command == "creategang")
            {
                text = CreateCommand.Create(msg.Text, user.Id);
            }
            else if (command == "renamegang")
            {
                text = RenameCommand.Rename(user, msg.Text);
            }
            else if (command == "opencontribution")
            {
                try
                {
                    var array = msg.Text.Split(" ");

                    var count = long.Parse(array[0]);
                    var days  = long.Parse(array[1]);
                    text = OpenContributionCommand.Open(user.Id, count, days);
                }
                catch
                {
                    text = "❌ Вы указали неверные числа";
                }
            }
            else if (command == "racefriend")
            {
                try
                {
                    var array = msg.Text.Split(" ");
                    var id    = long.Parse(array[0]);
                    text = RaceFriendCommand.RunFriendBattle(user.Id, id, sender, bot, msg);
                }catch
                {
                    text = "Вы указали неверный id";
                }
            }
            else if (command == "addfriend")
            {
                try
                {
                    text = AddFriendCommand.AddFriend(user, msg.Text.ToLong(), sender);
                }
                catch
                {
                    text = "❌ Вы указали неверный Id.";
                }
            }
            else if (command == "removefriend")
            {
                try
                {
                    text = RemoveFriendCommand.RemoveFriend(user, msg.Text.ToLong());
                }
                catch
                {
                    text = "❌ Вы указали невеный Id.";
                }
            }
            else if (command == "sellcar")
            {
                try
                {
                    var array  = msg.Text.Split(" ");
                    var idUser = long.Parse(array[0]);
                    var price  = long.Parse(array[1]);

                    text = SellCarCommand.Sell(user, idUser, sender, price);
                }catch
                {
                    text = "❌ Произошла ошибка.";
                }
            }
            else if (command == "buycarnumber")
            {
                try
                {
                    var region = long.Parse(msg.Text);
                    if (region < 1 || region > 999)
                    {
                        text = "❌ Регион находится за пределом допустимого значения.";
                    }
                    else
                    {
                        text = BuyCarNumberCommand.BuyNumber(user, region);
                    }
                }
                catch
                {
                    text = "❌ Произошла ошибка.";
                }
            }
            else if (command == "sellnumber")
            {
                try
                {
                    var array  = msg.Text.Split(" ");
                    var idUser = long.Parse(array[0]);
                    var price  = long.Parse(array[1]);

                    text = SellNumberCommand.Sell(user, idUser, sender, price);
                }catch
                {
                    text = "❌ Произошла ошибка.";
                }
            }
            else if (command == "buychips")
            {
                try
                {
                    var count = msg.Text.ToLong();
                    text = BuyChipsCommand.BuyChips(user, count);
                }
                catch
                {
                    text = "❌ Произошла ошибка.";
                }
            }
            else if (command == "exchangechips")
            {
                try
                {
                    var count = msg.Text.ToLong();
                    text = ExchangeChipsCommand.ExchangeChips(user, count);
                }
                catch
                {
                    text = "❌ Произошла ошибка.";
                }
            }
            else if (command == "vipDonateBuy")
            {
                try
                {
                    var count = msg.Text.ToLong();
                    text = ExpDonateCommand.BuyExp(count, user);
                }
                catch
                {
                    text = "❌ Произошла ошибка.";
                }
            }
            else if (command == "carDonate")
            {
                try
                {
                    text = CarDonateCommand.CreateCar(msg.Text, user);
                }
                catch
                {
                    text = "❌ Произошла ошибка.";
                }
            }
            else if (command == "expDonate")
            {
                try
                {
                    var array  = msg.Text.Split(" ");
                    var power  = long.Parse(array[0]);
                    var weight = long.Parse(array[1]);

                    text = AcceptCustomCarCommand.SetParams(power, weight, user, sender);
                }catch
                {
                    text = "❌ Произошла ошибка.";
                }
            }
            else if (command == "customNumber")
            {
                try
                {
                    var number = msg.Text.ToLong();
                    text = BuyOtherItemCommand.CustomNumber(number.ToString(), user);
                }
                catch
                {
                    text = "❌ Произошла ошибка.";
                }
            }
            else if (command == "chatSend")
            {
                try
                {
                    var textMsg = msg.Text;
                    text = ChatCommand.Send(textMsg, user, sender);
                }
                catch (Exception e)
                {
                    text = $"❌ Произошла ошибка. {e}";
                }
            }
            else if (command == "newChatCreate")
            {
                try
                {
                    var number = msg.Text;
                    text = NewChatCommand.CreateChat(number, user, sender, bot);
                }
                catch
                {
                    text = "❌ Произошла ошибка.";
                }
            }

            var kb = new KeyboardBuilder(bot);

            kb.AddButton(ButtonsHelper.ToHomeButton());
            sender.Text(text, msg.ChatId, kb.Build());
            // UsersCommandHelper.GetHelper().Add("", user.Id);
        }
Exemple #16
0
        public Task <string> Handle(PutCommand <T> request, CancellationToken cancellationToken)
        {
            var result = repository.Update(request.Obj);

            return(Task.FromResult(result));
        }