Example #1
0
        public string Execute(int workstationNumber)
        {
            var client  = new NotificationServer.NotificationServerClient(_channel.Channel);
            var request = new ProductionStepsChangedRequest();
            var workstationProductionSteps = new WorkstationProductionSteps();

            if (workstationNumber == 1)
            {
                workstationProductionSteps.WorkstationId = _workstationId.ToString();
                var productionStep = new ProductionStep {
                    Id = _productionStep1Id.ToString()
                };
                workstationProductionSteps.ProductionSteps.Add(productionStep);
                productionStep = new ProductionStep {
                    Id = _productionStep2Id.ToString()
                };
                workstationProductionSteps.ProductionSteps.Add(productionStep);
                request.WorkstationsProductionSteps.Add(workstationProductionSteps);
            }
            else
            {
                workstationProductionSteps = new WorkstationProductionSteps();
                workstationProductionSteps.WorkstationId = _workstationId2.ToString();
                var productionStep = new ProductionStep {
                    Id = Guid.NewGuid().ToString()
                };
                workstationProductionSteps.ProductionSteps.Add(productionStep);
                productionStep = new ProductionStep {
                    Id = Guid.NewGuid().ToString()
                };
                workstationProductionSteps.ProductionSteps.Add(productionStep);
                request.WorkstationsProductionSteps.Add(workstationProductionSteps);
            }

            var response = client.ProductionStepsChanged(request);

            return(response.Result.ToString());
        }
Example #2
0
        public void CanCreateProductionJobForDifferentMarketSectors()
        {
            Equipment component1; Equipment component2;

            using (var session = ConfigurationProviderSqlServer.SessionFactory.OpenSession())
            {
                component1 = CreateComponentOfType(session, Types.MarketSectorType.Types.IBAR.Id, EquipmentTypeFlangeId, "B01", null, Types.ConductorMaterial.Types.Copper.Id, new [] { 2500 }, null);
                component2 = CreateComponentOfType(session, Types.MarketSectorType.Types.Resinbar.Id, EquipmentTypeFlangeId, "B01", null, Types.ConductorMaterial.Types.Copper.Id, new[] { 2500 }, null);
            }
            var components = new[] { component1, component2 };

            foreach (var component in components)
            {
                var productionJobId = CreateProductionJob(component);
                ProductionJobIds.Add(productionJobId);

                List <ProductionJobBuildStep> productionJobBuildSteps;
                using (var session = ConfigurationProviderSqlServer.SessionFactory.OpenSession())
                {
                    ProductionJobBuildStep productionJobBuildStepAlias = null;
                    ProductionJobEquipment productionJobEquipmentAlias = null;
                    ProductionJob          productionJobAlias          = null;
                    EquipmentTypeProductionStepDefinition equipmentTypeProductionStepDefinitionAlias = null;
                    EquipmentTypeProductionDefinition     equipmentTypeProductionDefinitionAlias     = null;
                    ProductionDefinition      productionDefinitionAlias      = null;
                    ProductionStepDefinition  productionStepDefinitionAlias  = null;
                    ProductionStep            productionStepAlias            = null;
                    ProductionStageDefinition productionStageDefinitionAlias = null;
                    ProductionPart            productionPartAlias            = null;
                    productionJobBuildSteps = session.QueryOver(() => productionJobBuildStepAlias)
                                              .JoinAlias(e => e.ProductionJobEquipment, () => productionJobEquipmentAlias)
                                              .JoinAlias(() => productionJobEquipmentAlias.ProductionJob, () => productionJobAlias)
                                              .JoinAlias(() => productionJobBuildStepAlias.EquipmentTypeProductionStepDefinition, () => equipmentTypeProductionStepDefinitionAlias)
                                              .JoinAlias(() => equipmentTypeProductionStepDefinitionAlias.EquipmentTypeProductionDefinition, () => equipmentTypeProductionDefinitionAlias)
                                              .JoinAlias(() => equipmentTypeProductionDefinitionAlias.ProductionDefinition, () => productionDefinitionAlias)
                                              .JoinAlias(() => equipmentTypeProductionStepDefinitionAlias.ProductionStepDefinition, () => productionStepDefinitionAlias)
                                              .JoinAlias(() => productionStepDefinitionAlias.Step, () => productionStepAlias)
                                              .JoinAlias(() => productionStepDefinitionAlias.ProductionStageDefinition, () => productionStageDefinitionAlias)
                                              .JoinAlias(() => productionStageDefinitionAlias.ProductionPart, () => productionPartAlias)
                                              .Where(() => productionJobAlias.Id == productionJobId)
                                              .Future <ProductionJobBuildStep>()
                                              .ToList();
                }
                var productionDefinition = productionJobBuildSteps.First().EquipmentTypeProductionStepDefinition.EquipmentTypeProductionDefinition.ProductionDefinition;
                var productionStepIds    = productionJobBuildSteps.Select(p => p.EquipmentTypeProductionStepDefinition)
                                           .Select(e => e.ProductionStepDefinition)
                                           .Select(sd => sd.Step)
                                           .Select(s => s.Id)
                                           .ToList();

                if (component.Id == component1.Id)
                {
                    Assert.AreEqual(Types.ProductionDefinition.Definitions.IbarConductorHousingPair.Id, productionDefinition.Id);
                    Assert.Contains(Types.ProductionStep.Steps.Cm.Id, productionStepIds);
                    Assert.That(productionStepIds, Has.No.Member(Types.ProductionStep.Steps.Kf.Id));
                }

                if (component.Id == component2.Id)
                {
                    Assert.AreEqual(Types.ProductionDefinition.Definitions.ResinbarConductor.Id, productionDefinition.Id);
                    Assert.Contains(Types.ProductionStep.Steps.Kf.Id, productionStepIds);
                    Assert.That(productionStepIds, Has.No.Member(Types.ProductionStep.Steps.Cm.Id));
                }
            }
        }
Example #3
0
        public void IncludesPunchStepOnlyWhenUnitReferenceWhenEndsWithH()
        {
            Equipment component1; Equipment component2; Equipment component3; Equipment component4;

            using (var session = ConfigurationProviderSqlServer.SessionFactory.OpenSession())
            {
                component1 = CreateComponentOfType(session, Types.MarketSectorType.Types.Resinbar.Id, EquipmentTypeFlangeId, "B01", null, Types.ConductorMaterial.Types.Copper.Id, new[] { 2500 }, null);
                component2 = CreateComponentOfType(session, Types.MarketSectorType.Types.Resinbar.Id, EquipmentTypeFlangeId, "B02", "", Types.ConductorMaterial.Types.Copper.Id, new[] { 2500 }, null);
                component3 = CreateComponentOfType(session, Types.MarketSectorType.Types.Resinbar.Id, EquipmentTypeFlangeId, "B03", "HG", Types.ConductorMaterial.Types.Copper.Id, new[] { 2500 }, null);
                component4 = CreateComponentOfType(session, Types.MarketSectorType.Types.Resinbar.Id, EquipmentTypeFlangeId, "B04", "GH", Types.ConductorMaterial.Types.Copper.Id, new[] { 2500 }, null);
            }
            var components = new[] { component1, component2, component3, component4 };

            foreach (var component in components)
            {
                var productionJobId = CreateProductionJob(component);
                ProductionJobIds.Add(productionJobId);

                List <ProductionJobBuildStep> productionJobBuildSteps;
                using (var session = ConfigurationProviderSqlServer.SessionFactory.OpenSession())
                {
                    ProductionJobBuildStep productionJobBuildStepAlias = null;
                    ProductionJobEquipment productionJobEquipmentAlias = null;
                    ProductionJob          productionJobAlias          = null;
                    EquipmentTypeProductionStepDefinition equipmentTypeProductionStepDefinitionAlias = null;
                    EquipmentTypeProductionDefinition     equipmentTypeProductionDefinitionAlias     = null;
                    ProductionDefinition      productionDefinitionAlias      = null;
                    ProductionStepDefinition  productionStepDefinitionAlias  = null;
                    ProductionStep            productionStepAlias            = null;
                    ProductionStageDefinition productionStageDefinitionAlias = null;
                    ProductionPart            productionPartAlias            = null;
                    productionJobBuildSteps = session.QueryOver(() => productionJobBuildStepAlias)
                                              .JoinAlias(e => e.ProductionJobEquipment, () => productionJobEquipmentAlias)
                                              .JoinAlias(() => productionJobEquipmentAlias.ProductionJob, () => productionJobAlias)
                                              .JoinAlias(() => productionJobBuildStepAlias.EquipmentTypeProductionStepDefinition, () => equipmentTypeProductionStepDefinitionAlias)
                                              .JoinAlias(() => equipmentTypeProductionStepDefinitionAlias.EquipmentTypeProductionDefinition, () => equipmentTypeProductionDefinitionAlias)
                                              .JoinAlias(() => equipmentTypeProductionDefinitionAlias.ProductionDefinition, () => productionDefinitionAlias)
                                              .JoinAlias(() => equipmentTypeProductionStepDefinitionAlias.ProductionStepDefinition, () => productionStepDefinitionAlias)
                                              .JoinAlias(() => productionStepDefinitionAlias.Step, () => productionStepAlias)
                                              .JoinAlias(() => productionStepDefinitionAlias.ProductionStageDefinition, () => productionStageDefinitionAlias)
                                              .JoinAlias(() => productionStageDefinitionAlias.ProductionPart, () => productionPartAlias)
                                              .Where(() => productionJobAlias.Id == productionJobId)
                                              .Future <ProductionJobBuildStep>()
                                              .ToList();
                }
                var productionStepIds = productionJobBuildSteps.Select(p => p.EquipmentTypeProductionStepDefinition)
                                        .Select(e => e.ProductionStepDefinition)
                                        .Select(sd => sd.Step)
                                        .Select(s => s.Id)
                                        .ToList();

                if (component.Id == component4.Id)
                {
                    Assert.Contains(Types.ProductionStep.Steps.Punch.Id, productionStepIds);
                }
                else
                {
                    Assert.That(productionStepIds, Has.No.Member(Types.ProductionStep.Steps.Punch.Id));
                }
            }
        }
        public static RecipeGraph CreateFactory(RecipeGraph recipe)
        {
            if (recipe == null)
            {
                throw new ArgumentNullException("recipe");
            }

            var inputs     = new List <SourceStep>();
            var outputs    = new List <SinkStep>();
            var wastes     = new List <SinkStep>();
            var resources  = new List <FlowStep>();
            var transforms = new List <TransformStep>();

            foreach (var resource in recipe.Resources)
            {
                resources.Add(new FlowStep(resource.Item)
                {
                    Parent = resource
                });
            }

            foreach (var input in recipe.InputNodes)
            {
                var r = new FlowStep(input.Item)
                {
                    Parent = input
                };
                var s = new SourceStep(input.Item)
                {
                    Parent = input
                };

                r.Previous.Add(s);

                resources.Add(r);
                inputs.Add(s);
            }

            foreach (var output in recipe.OutputNodes)
            {
                var r = new FlowStep(output.Item)
                {
                    Parent = output
                };
                var o = new SinkStep(output.Item)
                {
                    Parent = output
                };

                o.Previous.Add(r);

                resources.Add(r);
                outputs.Add(o);
            }

            foreach (var waste in recipe.WasteNodes)
            {
                var w = new SinkStep(waste.Item)
                {
                    Parent = waste
                };
                wastes.Add(w);
                w.Previous.Add(resources.Where((r) => r.Item.Item == waste.Item.Item).First());
            }

            foreach (var transform in recipe.Transformations)
            {
                var amount          = transform.Amount;
                var transformRecipe = transform.Recipe;
                var building        = FirstMatchingBuilding(transformRecipe.Buildings);
                var modTime         = building.MaxProductionFor(transformRecipe);
                var nrOfFactories   = Math.Ceiling(amount / modTime);

                for (int i = 0; i < nrOfFactories; i++)
                {
                    var p = new ProductionStep(transform.Recipe, transform.Amount / nrOfFactories, building)
                    {
                        Parent = transform
                    };
                    foreach (var input in transformRecipe.Ingredients)
                    {
                        p.Previous.Add(resources.Where((r) => r.Item.Item == input.Item).First());
                    }

                    foreach (var output in transformRecipe.Results)
                    {
                        resources.Where((r) => r.Item.Item == output.Item).First().Previous.Add(p);
                    }

                    transforms.Add(p);
                }
            }

            return(new RecipeGraph(wastes, inputs, outputs, resources, transforms));
        }