Exemplo n.º 1
0
        public async Task <IActionResult> Activate([FromRoute] int id)
        {
            if (id <= 0)
            {
                return(BadRequest());
            }

            try
            {
                await _clientService.ActivateClient(id);
            }
            catch (NullReferenceException)
            {
                if (!(await _clientService.ClientExists(id)))
                {
                    return(NotFound());
                }
            }
            catch (DbUpdateException)
            {
                return(BadRequest());
            }

            return(Ok());
        }
        public void ActivateClient_Success()
        {
            // Arrange
            var existingClient = new ClientModel {
                Id = 1, Name = "Client1", MemberCode = "client1", IsDeleted = true
            };

            _mockDb.Setup(m => m.Clients)
            .Returns(TestHelper.GetQueryableMockDbSet(new List <ClientModel> {
                existingClient
            }));
            // Act
            _service.ActivateClient(existingClient.Id);
            // Assert
            Assert.IsFalse(existingClient.IsDeleted, "Expected client to be active");
            _mockDb.Verify(m => m.SaveChanges(), Times.Once, "Expected db changes to be saved");
        }
        public ClientAdminModule(IClientService clientService) : base("/admin/clients")
        {
            Get ["/"] = parameters =>
            {
                var clientList = clientService.GetAll();
                return(View["Views/Admin/ClientAdminSearch", clientList]);
            };

            Get ["/{ClientIdentity}"] = parameters =>
            {
                Guid clientIdentity;
                if (!(Guid.TryParse(parameters.ClientIdentity, out clientIdentity)))
                {
                    throw new ArgumentException("The Client Identity must be a Guid");
                }

                string       result = Request.Query.result.HasValue ? Request.Query.result : string.Empty;
                ClientResult clientResult;
                if (Enum.TryParse <ClientResult>(result, out clientResult))
                {
                    ViewBag.ValidationMessage = ClientMessageService.GetValidationMessage(clientResult);
                }

                var client = clientService.GetClient(clientIdentity);

                return(View["Views/Admin/ClientAdminDetail", client]);
            };

            Get ["/new"] = parameters =>
            {
                var emptyClient = new ClientViewModel {
                    ClientName = string.Empty, ContactName = string.Empty, ContactPhone = string.Empty, ContactEmail = string.Empty, Status = string.Empty
                };
                return(View["Views/Admin/ClientAdminDetail", emptyClient]);
            };

            Post ["/activate"] = parameters =>
            {
                Guid clientIdentity;
                if (!(Guid.TryParse(Request.Form.clientIdentity, out clientIdentity)))
                {
                    throw new ArgumentException("The Client Identity must be a Guid");
                }

                var client = clientService.ActivateClient(clientIdentity);

                return(Response.AsRedirect("~/admin/clients/" + client.ClientIdentity + "?result=" + ClientResult.ActivateClient.ToString()));
            };

            Post ["/"] = parameters =>
            {
                var viewModel = this.Bind <ClientViewModel>();

                ClientViewModel client;
                ClientResult    result;

                var validationResult = this.Validate(viewModel);
                var errorMessages    = new List <string>();
                foreach (var errorResult in validationResult.Errors.Values)
                {
                    errorMessages.AddRange(errorResult.Select(e => e.ErrorMessage));
                }

                ViewBag.ErrorMessages = string.Join("|", errorMessages);

                if (!validationResult.IsValid)
                {
                    return(View["Views/Admin/ClientAdminDetail", viewModel]);
                }

                if (viewModel.ClientIdentity.Equals(Guid.Empty))
                {
                    client = clientService.SaveNewClient(viewModel);
                    result = ClientResult.SaveNewClient;
                }
                else
                {
                    client = clientService.UpdateClient(viewModel);
                    result = ClientResult.SaveExistingClient;
                }
                return(Nancy.FormatterExtensions.AsRedirect(Response, "~/admin/clients/" + client.ClientIdentity + "?result=" + result.ToString()));
            };
        }