public async Task <IActionResult> Delete(Guid projectId)
        {
            var project = await projectsRepository
                          .GetAsync(projectId)
                          .ConfigureAwait(false);

            if (project is null)
            {
                return(new NotFoundResult());
            }

            var command = new ProjectDeleteCommand(CurrentUser, project);

            var commandResult = await orchestrator
                                .InvokeAsync <Project>(command)
                                .ConfigureAwait(false);

            if (commandResult.Links.TryGetValue("status", out var statusUrl))
            {
                return(new AcceptedResult(statusUrl, commandResult));
            }
            else
            {
                return(new OkObjectResult(commandResult));
            }
        }
        public void ProjectDeleteCommandHandler_Handle()
        {
            var user    = FakeObjects.TestUserWithId();
            var project = FakeObjects.TestProjectWithId();

            Project deletedTeam = null;

            var command = new ProjectDeleteCommand()
            {
                Id     = project.Id,
                UserId = user.Id
            };

            using (var session = _store.OpenSession())
            {
                session.Store(user);
                session.Store(project);

                var commandHandler = new ProjectDeleteCommandHandler(session);

                commandHandler.Handle(command);

                session.SaveChanges();

                deletedTeam = session.Load <Project>(project.Id);
            }

            Assert.IsNull(deletedTeam);
        }
        public async Task <IActionResult> Delete([FromBody] ProjectDeleteCommand projectDeleteCmd)
        {
            var result = await _mediator.Send(projectDeleteCmd);

            if (result)
            {
                return(Ok());
            }
            else
            {
                return(BadRequest());
            }
        }
Esempio n. 4
0
        public async Task <IActionResult> DeletProjectsPortifolio(int id)
        {
            var productCmd = new ProjectDeleteCommand()
            {
                ProjectId = id
            };

            var myContent     = JsonConvert.SerializeObject(productCmd);
            var stringContent = new StringContent(myContent, UnicodeEncoding.UTF8, "application/json");

            await Tests.Common.Extensions.HttpClientExtensions.DeleteAsync(client, "https://localhost:44301/api/projects", stringContent);

            return(Ok());
        }
        public async Task Deveria_excluir_reserva_de_Project_com_sucesso()
        {
            Project reservation = ProjectBuilder.Start()
                                  .Build();

            _fakeRepository.Setup(x => x.GetById(It.IsAny <int>())).ReturnsAsync(reservation);

            var cmd = new ProjectDeleteCommand()
            {
                ProjectId = 1
            };

            var result = await _handler.Handle(cmd, It.IsAny <CancellationToken>());

            result.Should().BeTrue();
            _fakeRepository.Verify(x => x.GetById(cmd.ProjectId), Times.Once);
            _fakeRepository.Verify(x => x.DeleteById(cmd.ProjectId), Times.Once);
        }
        public void DeletProject_IntegrationTest()
        {
            //arrange
            var project = ProjectBuilder.Start().Build();

            CustomWebApplicationFactory <Startup> .appDb.Project.Add(project);

            CustomWebApplicationFactory <Startup> .appDb.SaveChanges();

            var projectCmd = new ProjectDeleteCommand()
            {
                ProjectId = project.Id
            };
            var myContent     = JsonConvert.SerializeObject(projectCmd);
            var stringContent = new StringContent(myContent, UnicodeEncoding.UTF8, "application/json");

            //action
            var httpResponse = ProjectsPortifolio.Tests.Common.Extensions.HttpClientExtensions.DeleteAsync(_client, _url, stringContent).Result;

            httpResponse.EnsureSuccessStatusCode();

            //CustomWebApplicationFactory<Startup>.appDb.Project.Count().Should().Be(1);
        }