public async Task <ProductionOrderQuality> updateProductionOrderQuality(int productionOrderQualityId,
                                                                                ProductionOrderQuality productioQualityUpdate)
        {
            var productionOrderQualityDB = await _context.ProductionOrderQualities
                                           .Where(x => x.productionOrderQualityId == productionOrderQualityId)
                                           .Include(x => x.calculateInitial)
                                           .Include(x => x.Analysis)
                                           .ThenInclude(x => x.messages)
                                           .Include(x => x.Analysis)
                                           .ThenInclude(x => x.comp)
                                           .AsNoTracking()
                                           .FirstOrDefaultAsync();

            if (productionOrderQualityDB == null &&
                productionOrderQualityDB.productionOrderQualityId != productionOrderQualityId)
            {
                Console.WriteLine("ProductionOrderQualityService");
                Console.WriteLine("productionOrderQualityDB == null && productionOrderQualityDB.productionOrderQualityId != productionOrderQualityId");
                return(null);
            }

            productionOrderQualityDB.forno   = productioQualityUpdate.forno;
            productionOrderQualityDB.corrida = productioQualityUpdate.corrida;
            productionOrderQualityDB.posicao = productioQualityUpdate.posicao;
            productionOrderQualityDB.productionOrderNumber = productioQualityUpdate.productionOrderNumber;
            productionOrderQualityDB.status           = productioQualityUpdate.status;
            productionOrderQualityDB.qntForno         = productioQualityUpdate.qntForno;
            productionOrderQualityDB.calculateInitial = productioQualityUpdate.calculateInitial;

            //_context.ProductionOrderQualities.Update(productionOrderQualityDB);
            await _context.SaveChangesAsync();

            return(productionOrderQualityDB);
        }
        public async Task <ProductionOrderQuality> AddProductionOrderQuality(ProductionOrder productionOrder)
        {
            ProductionOrderQuality productionOrderQuality = new ProductionOrderQuality();

            var tool = await GetToolApi(productionOrder.currentThing.thingId);

            // if(tool == null)//if(tool == null || tool.Count == 0)
            // {
            //     Console.WriteLine("Ferramenta nula");
            //     return null;
            // }


            productionOrderQuality.productionOrderNumber = productionOrder.productionOrderNumber;
            productionOrderQuality.productionOrderId     = productionOrder.productionOrderId;
            productionOrderQuality.forno    = "Nome da Ferramenta"; //tool.FirstOrDefault().name;
            productionOrderQuality.corrida  = 0;                    //Convert.ToInt32(tool.FirstOrDefault().currentLife);
            productionOrderQuality.posicao  = productionOrder.currentThing.thingName;
            productionOrderQuality.status   = "create";
            productionOrderQuality.qntForno = productionOrder.quantForno;

            _context.ProductionOrderQualities.Add(productionOrderQuality);
            await _context.SaveChangesAsync();

            return(productionOrderQuality);
        }
Beispiel #3
0
        public async Task <ProductionOrderQuality> GetQualityPerProductionOrderId(int productionOrderId)
        {
            ProductionOrderQuality productionOrderQuality = null;

            client.DefaultRequestHeaders.Accept.Clear();
            client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
            var builder = new UriBuilder(_configuration["qualityService"]);
            var query   = HttpUtility.ParseQueryString(builder.Query);

            builder.Query = query.ToString();
            string url = builder.ToString() + productionOrderId;

            var result = await client.GetAsync(url);

            if (result.StatusCode == HttpStatusCode.OK)
            {
                productionOrderQuality = JsonConvert.DeserializeObject <ProductionOrderQuality>(await client.GetStringAsync(url));
            }

            return(productionOrderQuality);
        }
Beispiel #4
0
        private async Task <List <MessageCalculates> > CalculatesAnalysis(Analysis analysisReal, ProductionOrder productionOrder,
                                                                          double furnaceQuantity, ProductionOrderQuality productionOrderQuality, bool ajuste)
        {
            List <MessageCalculates> messages     = new List <MessageCalculates> ();
            List <string>            stringReturn = new List <string> ();
            double       maxForno              = Convert.ToDouble(_configuration["maxForno"]);
            double       porcentagemForno      = Convert.ToDouble(_configuration["porcentagemForno"]);
            int          cobreFosforosoId      = Convert.ToInt32(_configuration["cobreFosforosoId"]);
            AnalysisComp analysisCobreEstimada = new AnalysisComp();
            double       qtdForno              = 0;

            if (!ajuste)
            {
                maxForno = maxForno * (porcentagemForno / 100);
            }

            // Removendo cobre fosforoso dos calculos PONTO 1/2
            var cobreFosforosoComp = analysisReal.comp.Where(x => x.productId == cobreFosforosoId).FirstOrDefault();

            if (cobreFosforosoComp != null)
            {
                analysisReal.comp.Remove(cobreFosforosoComp);
            }
            // Fim da remoção 1/2

            foreach (var compAnalysis in analysisReal.comp)
            {
                var componenteRecipe = productionOrder.recipe.phases.FirstOrDefault()
                                       .phaseProducts
                                       .Where(x => x.product.productId == compAnalysis.productId).FirstOrDefault();

                if (componenteRecipe == null)
                {
                    compAnalysis.type = "contaminent";
                }
                else
                {
                    compAnalysis.type = componenteRecipe.phaseProductType.ToLower();
                }

                compAnalysis.valueKg = (compAnalysis.value / 100) * furnaceQuantity;
            }

            List <AnalysisComp> analysisRecipeList = new List <AnalysisComp> ();

            foreach (var compRecipe in productionOrder.recipe.phases.FirstOrDefault().phaseProducts)
            {
                // Removendo cobre fosforoso dos calculos PONTO 2/2
                if (compRecipe.product.productId == cobreFosforosoId)
                {
                    continue;
                }
                // Fim da remoção 2/2

                // Retirando contaminantes
                if (compRecipe.phaseProductType.ToLower() == "contaminent" || compRecipe.phaseProductType.ToLower() == "scrap" || compRecipe.phaseProductType.ToLower() == "semi_finished")
                {
                    continue;
                }

                AnalysisComp analysisRecipe = new AnalysisComp();
                analysisRecipe.productId   = compRecipe.product.productId;
                analysisRecipe.productName = compRecipe.product.productName;
                analysisRecipe.value       = ((compRecipe.maxValue - compRecipe.minValue) / 2) + compRecipe.minValue;
                analysisRecipe.valueKg     = (analysisRecipe.value / 100) * maxForno;

                analysisRecipeList.Add(analysisRecipe);
            }

            List <AnalysisComp> analysisEstimadaList = new List <AnalysisComp> ();

            qtdForno = analysisReal.comp.Where(a => a.type == "contaminent").Sum(a => a.valueKg);
            qtdForno = analysisReal.comp.Where(a => a.type == "scrap").Sum(a => a.valueKg);

            foreach (var comp in analysisRecipeList)
            {
                AnalysisComp analysisEstimada = new AnalysisComp();
                analysisEstimada.productId   = comp.productId;
                analysisEstimada.productName = comp.productName;

                AnalysisComp compAnalysis = analysisReal.comp.Where(x => x.productId == comp.productId).FirstOrDefault();

                if (compAnalysis == null)
                {
                    compAnalysis             = new AnalysisComp();
                    compAnalysis.productId   = comp.productId;
                    compAnalysis.productName = comp.productName;
                    compAnalysis.value       = 0;
                    compAnalysis.valueKg     = 0;
                }

                analysisEstimada.value = (comp.valueKg / maxForno) * 100;

                analysisEstimada.valueKg = comp.valueKg - compAnalysis.valueKg;

                if (analysisEstimada.valueKg < 0)
                {
                    qtdForno = qtdForno + (analysisEstimada.valueKg * -1) + compAnalysis.valueKg;
                }
                else
                {
                    qtdForno = qtdForno + analysisEstimada.valueKg + compAnalysis.valueKg;
                }

                Console.WriteLine("estimada " + analysisEstimada.valueKg);
                Console.WriteLine("analise " + compAnalysis.valueKg);
                Console.WriteLine("Forno " + qtdForno);
                if (qtdForno > maxForno)
                {
                    messages = new List <MessageCalculates> ();
                    MessageCalculates message = new MessageCalculates();
                    message.key       = "Excesso de Carga!";
                    message.value     = "0";
                    message.productId = 0;
                    messages.Add(message);
                    return(messages);
                }
                //productionOrderQuality.qntForno = qtdForno;
                if (analysisEstimada.valueKg > 0)
                {
                    MessageCalculates message = new MessageCalculates();
                    message.key       = analysisEstimada.productName;
                    message.productId = analysisEstimada.productId;
                    message.value     = analysisEstimada.valueKg.ToString();

                    messages.Add(message);
                }
            }
            await _productionOrderQualityService.updateProductionOrderQuality(productionOrderQuality.productionOrderQualityId, productionOrderQuality);

            return(messages);
        }