Exemplo n.º 1
0
        public async Task UpdateShouldSucceed()
        {
            // Arrange
            var id            = Guid.NewGuid();
            var name          = "name";
            var filterContent = "{\"sources\":[{\"id\":\"dcfe1db6-2484-42c2-9d9e-a77a28a5078d\",\"name\":\"BKAL33+KBT T\",\"description\":\"Plato Chemicals Test\",\"sourceBusinessUnits\":[]}],\"operations\":[{\"id\":\"d2760435-9d0b-4b69-adce-09017f2840c6\",\"name\":\"Unload into warehouse\",\"description\":\"Unloading goods into the warehouse\",\"icon\":null,\"tags\":[\"string\"]}]}";
            var filter        = JsonConvert.DeserializeObject <FlowFilter>(filterContent);

            var flow    = RepositoryHelper.ForFlow.CreateFlow(id, name);
            var diagram = "diagram";

            flow.SetDiagram(diagram);
            flow.SetFilterContent(filterContent);
            flow.SetFilter(filter);


            // Act
            await _repository.UpdateAsync(flow);

            // Assert
            var data = RepositoryHelper.ForFlow.GetFlows();

            data.Should().HaveCount(1);
            var result = data.First();

            result.Should().NotBeNull();
            result.Diagram.Should().Be(diagram);
            result.Filter.Sources.Should().BeEquivalentTo(filter.Sources);
            result.Filter.Operations.Should().BeEquivalentTo(filter.Operations);
            result.Filter.Sites.Should().BeEquivalentTo(filter.Sites);
            result.Filter.OperationalDepartments.Should().BeEquivalentTo(filter.OperationalDepartments);
            result.Filter.TypePlannings.Should().BeEquivalentTo(filter.TypePlannings);
            result.Filter.Customers.Should().BeEquivalentTo(filter.Customers);
            result.Filter.ProductionSites.Should().BeEquivalentTo(filter.ProductionSites);
            result.Filter.TransportTypes.Should().BeEquivalentTo(filter.TransportTypes);
        }
        public async Task <Result> Handle(UpdateFlowCommand request, CancellationToken cancellationToken)
        {
            Result result;

            try
            {
                var flow = await _flowReadRepository.GetAsync(request.Id);

                if (flow.Version != request.Version)
                {
                    throw new CommandVersionException();
                }

                if (request.Name.HasValue)
                {
                    flow.ChangeName(request.Name.Value);
                }
                if (request.Description.HasValue)
                {
                    flow.SetDescription(request.Description.Value);
                }
                if (request.Image.HasValue)
                {
                    flow.SetImage(request.Image.Value);
                }
                if (request.Diagram.HasValue)
                {
                    flow.SetDiagram(request.Diagram.Value);
                }
                if (request.FilterContent.HasValue)
                {
                    flow.SetFilterContent(request.FilterContent.Value);
                    var filter = _jsonService.Deserialize <FlowFilter>(request.FilterContent.Value.ToString());

                    filter.Sources = (filter.Sources.IsEnumerableNullOrEmpty()) ? new List <FlowSource> {
                        new FlowSource("x")
                    } : new List <FlowSource>(filter.Sources);
                    filter.Operations = (filter.Operations.IsEnumerableNullOrEmpty()) ? new List <FlowOperation> {
                        new FlowOperation("x")
                    } : new List <FlowOperation>(filter.Operations);
                    filter.Sites = (filter.Sites.IsEnumerableNullOrEmpty()) ? new List <FlowSite> {
                        new FlowSite("x")
                    } : new List <FlowSite>(filter.Sites);
                    filter.OperationalDepartments = (filter.OperationalDepartments.IsEnumerableNullOrEmpty()) ? new List <FlowOperationalDepartment> {
                        new FlowOperationalDepartment("x")
                    } : new List <FlowOperationalDepartment>(filter.OperationalDepartments);
                    filter.TypePlannings = (filter.TypePlannings.IsEnumerableNullOrEmpty()) ? new List <FlowTypePlanning> {
                        new FlowTypePlanning("x")
                    } : new List <FlowTypePlanning>(filter.TypePlannings);
                    filter.Customers = (filter.Customers.IsEnumerableNullOrEmpty()) ? new List <FlowCustomer> {
                        new FlowCustomer("x")
                    } : new List <FlowCustomer>(filter.Customers);
                    filter.ProductionSites = (filter.ProductionSites.IsEnumerableNullOrEmpty()) ? new List <FlowProductionSite> {
                        new FlowProductionSite("x")
                    } : new List <FlowProductionSite>(filter.ProductionSites);
                    filter.TransportTypes = (filter.TransportTypes.IsEnumerableNullOrEmpty()) ? new List <FlowTransportType> {
                        new FlowTransportType("x")
                    } : new List <FlowTransportType>(filter.TransportTypes);
                    filter.DriverWait = (filter.DriverWait == null) ? "x" : filter.DriverWait;

                    flow.SetFilter(filter);
                }

                flow.Version = _versionProvider.Generate();
                await _flowWriteRepository.UpdateAsync(flow);

                result = Result.Ok(flow.Version);
            }
            catch (EntityNotFoundDbException)
            {
                result = Result.Fail(new System.Collections.Generic.List <Failure>()
                {
                    new HandlerFault()
                    {
                        Code    = HandlerFaultCode.NotFound.Name,
                        Message = string.Format(HandlerFailures.NotFound, "Flow"),
                        Target  = "id"
                    }
                }
                                     );
            }
            catch (CommandVersionException)
            {
                result = Result.Fail(new System.Collections.Generic.List <Failure>()
                {
                    new HandlerFault()
                    {
                        Code    = HandlerFaultCode.NotMet.Name,
                        Message = HandlerFailures.NotMet,
                        Target  = "version"
                    }
                }
                                     );
            }
            catch (UniqueKeyException)
            {
                result = Result.Fail(new System.Collections.Generic.List <Failure>()
                {
                    new HandlerFault()
                    {
                        Code    = HandlerFaultCode.Conflict.Name,
                        Message = HandlerFailures.Conflict,
                        Target  = "name"
                    }
                }
                                     );
            }
            catch
            {
                result = Result.Fail(CustomFailures.UpdateFlowFailure);
            }

            return(result);
        }