src/Controller/ProjectController.php line 288

Open in your IDE?
  1. <?php
  2. declare(strict_types=1);
  4. namespace App\Controller;
  6. use App\Data\NutritionalInfo;
  7. use App\Entity\ProductionRecipe;
  8. use App\Entity\Project;
  9. use App\Entity\ProjectCalcs;
  10. use App\Entity\RawMaterial;
  11. use App\Entity\Recipe;
  12. use App\Entity\RecipeTest;
  13. use App\Entity\RecipeTestRawMaterial;
  14. use App\Entity\Trial;
  15. use Doctrine\ORM\EntityManager;
  16. use Doctrine\ORM\EntityManagerInterface;
  17. use http\Exception\InvalidArgumentException;
  18. use phpDocumentor\Reflection\DocBlock\Tags\Method;
  19. use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
  20. use Symfony\Component\Console\Command\Command;
  21. use Symfony\Component\DependencyInjection\Tests\Compiler\J;
  22. use Symfony\Component\HttpFoundation\JsonResponse;
  23. use Symfony\Component\HttpFoundation\RedirectResponse;
  24. use Symfony\Component\HttpFoundation\RequestStack;
  25. use Symfony\Component\HttpKernel\Exception\HttpException;
  26. use Symfony\Component\Routing\Annotation\Route;
  27. use Symfony\Component\HttpFoundation\Request;
  28. use Sensio\Bundle\FrameworkExtraBundle\Configuration\Security;
  29. use Symfony\Component\Validator\Constraints\Json;
  31. class ProjectController extends AbstractController
  32. {
  33.     private readonly NutritionalInfo $nutricionalAmasada;
  34.     /**
  35.      * @var array[NutritionalInfo]
  36.      */
  37.     private array $nutricionalAntesHorno;
  38.     private NutritionalInfo $nutricionalCookie;
  39.     /** @var array[NutritionalInfo] */
  40.     private array $nutricionalDespuesHorno;
  42.     #[Route('/api/projects/info/{project}')]
  43.     public function getInfo(Project $project): JsonResponse
  44.     {
  45.         $testMethods = (new \ReflectionClass(RecipeTest::class))->getProperties();
  47.         $toRet = [
  48.             "@context" => '/api/contexts/Project',
  49.             '@id' => "/api/projects/{$project->getId()}",
  50.             "@type" => "Project",
  51.             "id" => $project->getId(),
  52.             "code" => $project->getCode(),
  53.             "type" => $project->getType(),
  54.             "name" => $project->getName(),
  55.             "state" => $project->getState(),
  56.             "category" => "/api/categories/{$project->getCategory()->getId()}",
  57.             "humidity" => $project->getHumidity(),
  58.             "observations" => $project->getObservations(),
  59.             "recipes" => array_map(fn(Recipe $row) => [
  60.                 '@id' => "/api/recipes/{$row->getId()}",
  61.                 'id' => $row->getId(),
  62.                 'phase' => $row->getPhase(),
  63.                 'code' => $row->getCode(),
  64.                 'baking' => $row->getBaking(),
  65.                 'type' => $row->getType(),
  66.                 'observations' => $row->getObservations(),
  67.                 'nutriscore' => [],
  68.                 'tests' => array_map(function (RecipeTest $test) use($testMethods){
  69.                     $testArray = [];
  70.                     $testMethod = null;
  71.                     foreach ($testMethods as $testMethod) {
  72.                         $methodName = 'get' . str_replace('_', '', ucwords($testMethod->name, '_'));
  73.                         $methodType = $testMethod->getType()?->getName();
  74.                         if (is_string($methodType) && !str_starts_with($methodType, 'App')) {
  75.                             $testArray[$testMethod->name] = match ($methodType) {
  76.                                 'DateTimeInterface' => $test->$methodName()?->format('Y-m-d'),
  77.                                 default => $test?->$methodName(),
  78.                             };
  79.                         }
  80.                     }
  81.                     return $testArray;
  82.                 }, $row->getRecipeTests()->toArray())
  83.             ], $project->getRecipes()->toArray()),
  84.         ];
  86.         return new JsonResponse($toRet);
  87.     }
  89.     #[Route('/api/project/trials/{project}', name: 'api_project_final_tests')]
  90.     public function getFinalTests(EntityManagerInterface $entityManager, Project $project): JsonResponse
  91.     {
  92.         $toRet = [];
  94.         foreach ($project->getRecipes() as $recipe) {
  95.             foreach($recipe->getRecipeTests() as $recipeTest) {
  96.                 if ($recipeTest->getFinalTest()) {
  97.                     $toRet[] = [
  98.                         'id' => $recipeTest->getId(),
  99.                         'type' => $recipeTest->getType()
  100.                     ];
  101.                 }
  102.             }
  103.         }
  105.         return new JsonResponse($toRet);
  106.     }
  108.     /**
  109.      * Obtiene la información del valor de nutriscore y el precio del producto.
  110.      * Se llama en la ventana de presentación de la información del producto
  111.      */
  112.     #[Route('/api/projects/calc-info/{project}', name: 'api_project_get_calc_info')]
  113.     public function calcInfo(Project $project): JsonResponse
  114.     {
  115.         $calcs = $project->getProjectCalcs();
  116.         if ($calcs) {
  117.             return new JsonResponse([
  118.                 'nutriscore' => [
  119.                     'value' => $calcs->getNutriscoreProductoValor(),
  120.                     'letter' => $calcs->getNutriscoreProductoLetra(),
  121.                 ],
  122.                 'price' => [
  123.                     'amasada' => $calcs->getCosteAmasada(),
  124.                     'total' => $calcs->getCosteProductoTerminado(),
  125.                 ]
  126.             ]);
  127.         } else {
  128.             return new JsonResponse([]);
  129.         }
  130.     }
  132.     #[Route('/api/projects/finished-nutritional-info/{project}', name: 'api_project_get_finished_nutritional_info')]
  133.     public function finishedNutritionalInfo(Project $project): JsonResponse
  134.     {
  135.         $calcs = $project->getProjectCalcs();
  136.         if ($calcs) {
  137.             return new JsonResponse($calcs->getInformacionNutricionalProducto());
  138.         }
  140.         return new JsonResponse([]);
  141.     }
  143.     #[Route('/api/projects/close/{project}', name: 'api_close_project', methods: ["PATCH"])]
  144.     public function closeProject(EntityManagerInterface $entityManager, Project $project): JsonResponse
  145.     {
  146.         $recipeTypes = [
  147.             'Amasado' => false,
  148.             'Topping' => false,
  149.             'Relleno' => false,
  150.             'Cobertura' => false,
  151.         ];
  153.         $recipes = $project->getRecipes();
  154.         foreach ($recipes as $recipe) {
  155.             $type = $recipe->getType();
  156.             $recipeTypes[$type] = true;
  157.         }
  159.         $project->setAmasado($recipeTypes['Amasado']);
  160.         $project->setTopping($recipeTypes['Topping']);
  161.         $project->setRelleno($recipeTypes['Relleno']);
  162.         $project->setCobertura($recipeTypes['Cobertura']);
  163.         $project->setState('Terminado');
  165.         $entityManager->persist($project);
  166.         $entityManager->flush();
  168.         return new JsonResponse($recipeTypes);
  169.     }
  171.     #[Route('/api/projects/recipe_ingredients_info/{project}', name: 'api_recipe_ingredients_info')]
  172.     public function ingredients(Project $project): JsonResponse
  173.     {
  174.         $calcs = $project->getProjectCalcs();
  176.         if ($calcs) {
  177.             return new JsonResponse([
  178.                 'cookie' => $calcs->getIngredientesCookie(),
  179.                 'totalPesoCookie' => $calcs->getTotalPesoCookie(),
  180.                 'humedadHorneado' => $calcs->getHumedadHorneado(),
  181.                 'perdidaEstimada' => $calcs->getPerdidaEstimada(),
  182.                 'perdidaEstimadaPorcentaje' => $calcs->getPerdidaEstimadaPorcentaje(),
  183.                 'totalHorneado' => $calcs->getTotalHorneado(),
  184.                 'humedadGalleta' => $calcs->getHumedadGalleta(),
  185.                 'terminado' => $calcs->getIngredientesProductoTerminado(),
  186.             ]);
  187.         } else {
  188.             return new JsonResponse([]);
  189.         }
  190.     }
  192.     #[Route('/api/projects/list_costs/{project}', name: 'api_project_costs')]
  193.     public function listProjectCosts(Project $project): JsonResponse
  194.     {
  195.         $calcs = $project->getProjectCalcs();
  197.         if ($calcs) {
  198.             return new JsonResponse([
  199.                 'amasada' => array_values($calcs->getCostesAmasada()),
  200.                 'despuesHorno' => $calcs->getCostesDespuesHorno(),
  202.             ]);
  203.         } else {
  204.             return new JsonResponse([]);
  205.         }
  206.     }
  208.     #[Route('/api/projects/list_materials/{project}', name: 'api_project_list_materials')]
  209.     public function listProjectMaterials(EntityManagerInterface $entityManager, Project $project): JsonResponse
  210.     {
  211.         $rawMaterials = [];
  212.         $totalWeight = 0;
  214.         $ingredientesProductoTerminado = $project->getProjectCalcs()?->getIngredientesProductoTerminado();
  215.         $rawMaterialsEntity = $entityManager->getRepository(RawMaterial::class);
  216.         if ($ingredientesProductoTerminado) {
  217.             foreach ($ingredientesProductoTerminado as $ingrediente) {
  218.                 /** @var RawMaterial $material */
  219.                 $material = $rawMaterialsEntity->findOneBy(['id' => $ingrediente[4]]);
  221.                 $rawMaterials[$material->getId()] = [
  222.                     'id' => $material->getId(),
  223.                     'code' => $material->getCode(),
  224.                     'name' => $material->getName(),
  225.                     'marketName' => $material->getPublicName(),
  226.                     'quantity' => $ingrediente[3] / 1000, // <- a Kg,
  227.                     'raw_cost' => $material->getPrice(),
  228.                     'percentage' => 0
  229.                 ];
  231.                 $totalWeight += $ingrediente[3];
  232.             }
  234.             return new JsonResponse(array_map(function($r) use ($totalWeight) {
  235.                 $r['percentage'] = $r['quantity'] / $totalWeight * 1000;
  236.                 $r['cost'] = $r['percentage'] * $r['raw_cost'];
  237.                 return $r;
  238.             }, $rawMaterials));
  239.         } else {
  240.                 return new JsonResponse([]);
  242.         }
  243.     }
  245.     /**
  246.      * Crea nuevas pruebas finales para las recetas en producción así como un ensayo usando esas pruebas
  247.      */
  248.     #[Route('/api/projects/production-recipes/{project}', name: 'api_project_create_production_recipes', methods: ["POST"])]
  249.     public function createProductionRecipes(EntityManagerInterface $entityManager, Project $project): JsonResponse
  250.     {
  251.         $params = json_decode(file_get_contents('php://input'), true, 512, JSON_THROW_ON_ERROR);
  252.         $recetasFinalesProyecto = $entityManager->getRepository(Project::class)->getFinalRecipesIds($project->getId());
  253.         //var_dump($recetasFinalesProyecto);
  255.         foreach ($recetasFinalesProyecto as $idReceta) {
  256.             //echo "Comprando {$idReceta}\n";
  258.             if (array_search($idReceta, array_column($params, 'id')) === false) {
  259.                 return new JsonResponse([], \Symfony\Component\HttpFoundation\Response::HTTP_SERVICE_UNAVAILABLE);
  260.             }
  261.         }
  263.         //return new JsonResponse(['msg' => 'Todas las recetas encontradas']);
  264.         $entityManager->getRepository(Project::class)->createRecipes($project->getId(), $params);
  265.         return new JsonResponse([], \Symfony\Component\HttpFoundation\Response::HTTP_CREATED);
  266.     }
  268.     #[Route('/api/list/by-category', name: 'api_projects_by_category')]
  269.     public function listByType(EntityManagerInterface $entityManager): JsonResponse
  270.     {
  271.         return new JsonResponse($entityManager->getRepository(Project::class)->getListado(), \Symfony\Component\HttpFoundation\Response::HTTP_OK);
  272.     }
  274.     #[Route('/api/list/by-category-dates/{fechaInicio1}/{fechaFin1}/{fechaInicio2}/{fechaFin2}')]
  275.     public function listByTypeAndDate(EntityManagerInterface $entityManager, string $fechaInicio1, string $fechaFin1, string $fechaInicio2, string $fechaFin2): \Symfony\Component\HttpFoundation\Response
  276.     {
  277.         $projectRepo = $entityManager->getRepository(Project::class);
  278.         return new JsonResponse([
  279.             'segment1' => $projectRepo->getListadoEntre($fechaInicio1, $fechaFin1),
  280.             'segment2' => $projectRepo->getListadoEntre($fechaInicio2, $fechaFin2),
  281.         ]);
  282.     }
  284.     /**
  285.      * Obtiene la lista de recetas finales de un proyecto así como los materiales de las que está compuesto
  286.      */
  287.     #[Route('/api/projects/production-recipes/{project}', name: 'api_project_get_production_recipes', methods: ["GET"])]
  288.     public function productionRecipes(EntityManagerInterface $entityManager, int $project): JsonResponse
  289.     {
  290.         return new JsonResponse(
  291.             $entityManager->getRepository(Project::class)->getProductionRecipes($project)
  292.         );
  293.     }
  296.     /**
  297.      *
  298.      * @todo Convertir las sentencias de Doctrine a una SQL
  299.      *
  300.      */
  301.     #[Route('/api/projects/raw-material-resume/{project}', name: 'api_raw_material_resume')]
  302.     public function rawMaterialsResume(EntityManagerInterface $entityManager, Project $project): JsonResponse
  303.     {
  304.         $rawMaterials = [];
  305.         $totalWeight = 0;
  307.         // Compruebo si se ha guardado ya.
  308.         $productionRecipe = $project->getProductionRecipe();
  309.         if (null !== $productionRecipe) {
  310.             return new JsonResponse([
  311.                 'materials' => $productionRecipe->getRawMaterials(),
  312.                 'checklist' => $productionRecipe->getCheckList(),
  313.             ]);
  314.         } else {
  315.             $recipes = $project->getRecipes();
  316.             $rawMaterialsEntity = $entityManager->getRepository(RecipeTestRawMaterial::class);
  317.             $recipeTestsEntity = $entityManager->getRepository(RecipeTest::class);
  318.             foreach ($recipes as $recipe) {
  319.                 // Sí, no se hace automático
  320.                 $recipesTests = $recipeTestsEntity->findBy([
  321.                     'recipe' => $recipe,
  322.                     'finalTest' => true,
  323.                 ]);
  325.                 if (count($recipesTests) > 0) {
  326.                     $testRawMaterials = $rawMaterialsEntity->findBy([
  327.                         'recipeTest' => $recipesTests[0]
  328.                     ]);
  330.                     /** @var RecipeTestRawMaterial $testRawMaterial */
  331.                     foreach ($testRawMaterials as $testRawMaterial) {
  332.                         $material = $testRawMaterial->getRawMaterial();
  333.                         $materialId = $material->getId();
  334.                         if (!isset($rawMaterials[$materialId])) {
  335.                             $rawMaterials[$materialId] = [
  336.                                 'id' => $materialId,
  337.                                 'code' => $material->getCode(),
  338.                                 'name' => $material->getName(),
  339.                                 'marketName' => $material->getPublicName(),
  340.                                 'phases' => [],
  341.                                 'quantity' => 0,
  342.                                 'percentage' => 0,
  343.                                 'roundQuantity' => 0,
  344.                                 'roundPercentage' => 0,
  345.                             ];
  346.                         }
  348.                         $quantity = $testRawMaterial->getQuantity() / 1000;
  349.                         $rawMaterials[$materialId]['quantity'] += $quantity;
  350.                         $rawMaterials[$materialId]['roundQuantity'] = $rawMaterials[$materialId]['quantity'];
  351.                         $totalWeight += $quantity;
  352.                         $rawMaterials[$materialId]['phases'][] = $testRawMaterial->getPhase()->getCode();
  353.                     }
  354.                 }
  355.             }
  356.             return new JsonResponse([
  357.                 'checklist' => [
  358.                     'diagrama' => false,
  359.                     'diagramaNombre' => '',
  360.                     'etapaNueva' => false,
  361.                     'etapaNombre' => '',
  362.                     'riesgos' => false,
  363.                     'riesgosNombres' => '',
  364.                     'pcc' => false,
  365.                     'pccNombre' => '',
  366.                     'otros' => false,
  367.                     'otrosNombre' => '',
  368.                     'ingredientesAlergenos' => false,
  369.                     'alergenosPresentes' => '',
  370.                     'trazas' => '',
  371.                     'nuevos' => '',
  372.                     'vidaUtil' => '',
  373.                 ],
  374.                 'materials' => array_values(
  375.                     array_map(function ($row) use ($totalWeight) {
  376.                         $row['percentage'] = sprintf('%01.2f', (100 * $row['quantity']) / $totalWeight);
  377.                         $row['roundPercentage'] = $row['percentage'];
  378.                         return $row;
  379.                     }, $rawMaterials)
  380.                 )
  381.             ]);
  382.         }
  383.     }
  385.     /**
  386.      * @throws \HttpException
  387.      * @throws \JsonException
  388.      */
  389.     #[Route('/api/projects/production-checklist/{project}', name: "api_save_production_recipe_checklist", methods: ["POST"])]
  390.     public function saveProductionRecipe(EntityManagerInterface $entityManager, Project $project): JsonResponse
  391.     {
  392.         $params = json_decode(file_get_contents('php://input'), true, 512, JSON_THROW_ON_ERROR);
  394.         if (isset($params['checklist'])) {
  395.             $productionRecipe = $entityManager->getRepository(ProductionRecipe::class)->findOneBy(
  396.                 [
  397.                     'project' => $project
  398.                 ]
  399.             );
  401.             if (!$productionRecipe) {
  402.                 $productionRecipe = new ProductionRecipe();
  403.                 $productionRecipe->setProject($project);
  404.             }
  405.             $productionRecipe->setCheckList($params['checklist']);
  406.             $entityManager->persist($productionRecipe);
  407.             $entityManager->flush();
  409.             return new JsonResponse([]);
  410.         } else {
  411.             throw new HttpException(500,"Not valid params");
  412.         }
  413.     }
  415.     #[Route('/api/projects/{project}/print-final-trial', name: 'api_project_print_final_trial', methods: ["GET"])]
  416.     public function printFinalTrial(EntityManagerInterface $entityManager, Project $project): RedirectResponse
  417.     {
  418.         $trial = $entityManager->getRepository(Trial::class)->findOneBy([
  419.             'project' => $project,
  420.             'finalTrial' => true
  421.         ]);
  423.         if (!$trial) {
  424.             $trials = $entityManager->getRepository(Trial::class)->findBy([
  425.                 'project' => $project,
  426.             ], [
  427.                'id' => 'DESC'
  428.             ]);
  430.             if (count($trials) > 0) {
  431.                 $trial = $trials[0];
  432.             }
  433.         }
  435.         if ($trial) {
  436.             return $this->redirectToRoute('api_print_trial', ['trial' => $trial->getId()]);
  437.         }
  439.         throw new \Exception('El proyecto no tiene ensayo final', 403);
  440.     }
  442.     #[Route('/api/projects/production-recipe/{project}', name: "api_get_production_recipe", methods: ["GET"])]
  443.     public function productionRecipe(EntityManagerInterface $entityManager, Project $project): JsonResponse
  444.     {
  445.         $toRet = [
  446.             'materials' => null,
  447.             'checklist' => null
  448.         ];
  449.         /** @var ProductionRecipe $productionRecipe */
  450.         $productionRecipe = $entityManager->getRepository(ProductionRecipe::class)->findOneBy([
  451.             'project' => $project
  452.         ]);
  453.         if ($productionRecipe) {
  454.             $toRet['materials'] = $productionRecipe->getRawMaterials();
  455.             $toRet['checklist'] = $productionRecipe->getCheckList();
  456.         }
  458.         return new JsonResponse($toRet);
  459.     }
  461.     /**
  462.      * Calcula todos los valores del proyecto solicitado.
  463.      * Guarda los resultados en la entidad ProjectCalcs
  464.      * Devuelve el nutriscore final del cálculo.
  465.      *
  466.      * @todo Hay que refactorizar esto MUCHO
  467.      */
  468.     #[Route('/api/projects/calculate/{project}', name: 'api_project_calculate_all', methods: ['GET'])]
  469.     public function calculate(EntityManagerInterface $entityManager, Project $project): JsonResponse
  470.     {
  471.         $costes = [];
  472.         $projectCalcs = $project->getProjectCalcs();
  473.         if ($projectCalcs === null) {
  474.             $projectCalcs = new ProjectCalcs();
  475.             $project->setProjectCalcs($projectCalcs);
  476.         }
  477.         $projectCalcs->setCreation(new \DateTime());
  479.         $MaterialesUsados = [];
  480.         // Primero se identifican las recetas que vienen antes del horno
  481.         $beforeOvenKneading = null;
  482.         $beforeOvenOther = [];
  483.         $afterOven = [];
  484.         /** @var Recipe $recipe */
  485.         foreach ($project->getRecipes() as $recipe) {
  486.             if ($recipe->getPhase() === 0) {
  487.                 if ($recipe->getType() === 'Amasado') {
  488.                     $beforeOvenKneading = $recipe;
  489.                 } else {
  490.                     $beforeOvenOther[] = $recipe;
  491.                 }
  492.             } else {
  493.                 $afterOven[] = $recipe;
  494.             }
  495.         }
  497.         // Si no hay amasado no continuamos
  498.         if ($beforeOvenKneading === null) {
  499.             //$io->error("Este proyecto no tiene ninguna masa antes de horno");
  500.             throw new HttpException(501, 'Proyecto incompleto');
  501.         }
  503.         $recipeTestRawMaterialRepository = $entityManager->getRepository(RecipeTestRawMaterial::class);
  505.         // Estas son las recetas después del horno.
  506.         // Buscamos los tests finales para estas
  507.         $afterOvenTests = [];
  508.         $afterOvenBakingPercentage = [];
  509.         foreach ($afterOven as $recipe) {
  510.             $afterOvenBakingPercentage[] = $recipe->getBaking();
  511.             /** @var RecipeTest $recipeTest */
  512.             foreach ($recipe->getRecipeTests() as $recipeTest) {
  513.                 if ($recipeTest->getFinalTest() === true) {
  514.                     $afterOvenTests[] = $recipeTest;
  515.                 }
  516.             }
  517.         }
  518.         unset ($afterOven);
  520.         // Obtenemos los detalles de la fase final del amasado
  521.         $kneadingRecipeTest = null;
  522.         foreach ($beforeOvenKneading->getRecipeTests() as $recipeTest) {
  523.             if ($recipeTest->getFinalTest() === true) {
  524.                 $kneadingRecipeTest = $recipeTest;
  525.                 break;
  526.             }
  527.         }
  529.         $beforeOvenTests = [];
  530.         //$io->note("Número de recetas adicionales antes de horno: " . \count($beforeOvenOther));
  531.         foreach ($beforeOvenOther as $recipe) {
  532.             /** @var RecipeTest $recipeTest */
  533.             foreach ($recipe->getRecipeTests() as $recipeTest) {
  534.                 if ($recipeTest->getFinalTest() === true) {
  535.                     $beforeOvenTests[] = $recipeTest;
  537.                     //$io->note("Porcentaje " . $recipe->getBaking());
  538.                 }
  539.             }
  540.         }
  542.         if ($kneadingRecipeTest === null) {
  543.             throw new HttpException(501, 'No hay ningún test definido como final en la receta de amasado');
  544.         }
  546.         // Cálculos de porcentajes para los totales antes de horno
  547.         $totalPercentageBeforeOven = 0;
  548.         $N4 = 0; $N5 = 0; $N6 = 0;
  549.         $M3 = 100; $M4 = 0; $M5 = 0; $M6 = 0;
  550.         $porcentajesRecetas  = array_fill(0, \count($beforeOvenTests), 0);
  551.         $pesosInicialesRecetas = array_fill(0, \count($beforeOvenTests), 0);
  552.         $pesoRelacionAmasada = array_fill(0, \count($beforeOvenTests), 0);
  553.         if (\count($beforeOvenTests) > 0) {
  554.             $porcentajesRecetas[0] = $N4 = $beforeOvenOther[0]->getBaking() / 100;
  555.             $M4 = $M3 * $N4 / (1 - $N4);
  556.         }
  557.         if (\count($beforeOvenTests) > 1) {
  558.             $porcentajesRecetas[1] = $N5 = $beforeOvenOther[1]->getBaking() / 100;
  559.             $M5 = ($M3+$M4)*$N5/(1-$N5);
  560.         }
  561.         if (\count($beforeOvenTests) > 2) {
  562.             $porcentajesRecetas[2] = $N6 = $beforeOvenOther[2]->getBaking() / 100;
  563.             $M6 = ($M3+$M4+$M5)*$N6/(1-$N6);
  564.         }
  565.         $M7 = $M3 + $M4 + $M5 + $M6;
  567.         //var_dump($porcentajesRecetas);
  569.         /** Obtención de detalles de la masa para los cálculos del resto */
  570.         // Materiales de la receta masa
  571.         $materialesAmasado = $recipeTestRawMaterialRepository->findBy(['recipeTest' => $kneadingRecipeTest]);
  572.         // Porcentaje amasado
  573.         $pesoAmasada = array_reduce($materialesAmasado, fn($akk, $row)=> $akk + $row->getQuantity(), 0);
  574.         $J17 = $beforeOvenKneading->getBaking() / 100; //$M3 / $M7;
  576.         $recipesBeforeOvenCalcs = [];
  577.         $recipesAfterOvenCalcs = [];
  579.         $costes['before'] = [];
  580.         $costes['before']['others'] = [];
  582.         /** INGREDIENTES ANTES DE HORNO */
  583.         $BDIngredientesAntesHorno = [];
  584.         foreach ($beforeOvenTests as $key => $test) {
  585.             $recipeType = $test->getRecipe()->getType();
  586.             $costes['before']['others'][$recipeType] = [];
  587.             $this->nutricionalAntesHorno[$recipeType] = new NutritionalInfo();
  588.             $materials = $recipeTestRawMaterialRepository->findBy(['recipeTest' => $test]);
  589.             $pesosInicialesRecetas[$key] = array_reduce($materials, fn($akk, $row)=> $akk + $row->getQuantity(), 0);
  590.             // Sumatoria receta para una amasada [Total Masa Amasada * % Baking Receta / % Baking Masa Amasada]
  591.             $pesoRelacionAmasada[$key] = $pesoAmasada * $porcentajesRecetas[$key] / $J17;
  592.             //echo "Peso relación con la amasada para la receta {$key} => {$pesoAmasada} * {$porcentajesRecetas[$key]} / {$J17} => {$pesoRelacionAmasada[$key]}\n";
  593.             //echo "Peso inicial de la receta {$key}: {$pesosInicialesRecetas[$key]}\n";
  594.             $nombreTipo = $test->getRecipe()->getType();
  595.             $BDIngredientesAntesHorno[$nombreTipo] = [];
  597.             /** @var RecipeTestRawMaterial $material */
  598.             foreach($materials as $material) {
  599.                 $quantity = $material->getQuantity();
  600.                 $rawMaterial = $material->getRawMaterial();
  601.                 if (!isset($MaterialesUsados[$rawMaterial->getId()])) {
  602.                     $MaterialesUsados[$rawMaterial->getId()] = $rawMaterial;
  603.                 }
  604.                 // Se aplica el índice de corrección según los porcentajes de masa
  605.                 $quantityKneaded = $quantity * $pesoRelacionAmasada[$key] / $pesosInicialesRecetas[$key];
  607.                 $recipesBeforeOvenCalcs[$rawMaterial->getId()] = [$rawMaterial->getName(), $quantity, $quantity / 1000, $quantity / $pesosInicialesRecetas[$key], $quantityKneaded, $quantityKneaded / 1000];
  608.                 $BDIngredientesAntesHorno[$nombreTipo][] = $recipesBeforeOvenCalcs[$rawMaterial->getId()];
  610.                 /*echo "Información calculada para el material ", $rawMaterial->getName(), ":\n";
  611.                 var_dump($recipesBeforeOvenCalcs[$rawMaterial->getId()]);
  612.                 echo "\n\n";*/
  613.                 $costes['before']['others'][$recipeType][$rawMaterial->getId()] = [$rawMaterial->getName(), $quantity / $pesosInicialesRecetas[$key], $rawMaterial->getPrice(), $rawMaterial->getPrice() * ($quantity / $pesosInicialesRecetas[$key])];
  615.                 $this->nutricionalAntesHorno[$recipeType]->addRawMaterial($rawMaterial, $quantity / $pesosInicialesRecetas[$key]);
  616.             }
  617.         }
  618.         $projectCalcs->setIngredientesAntesHorno($BDIngredientesAntesHorno);
  619.         /** FIN INGREDIENTES ANTES DE HORNO */
  621.         /** INGREDIENTES DE LA MASA */
  622.         // Empezamos la cookie con la masa de amasado
  623.         $cookie = [];
  624.         $costes['before']['amasada'] = [];
  625.         foreach($materialesAmasado as $material) {
  626.             $rawMaterial = $material->getRawMaterial();
  627.             if (!isset($MaterialesUsados[$rawMaterial->getId()])) {
  628.                 $MaterialesUsados[$rawMaterial->getId()] = $rawMaterial;
  629.             }
  630.             $quantity = $material->getQuantity();
  631.             $cookie[$rawMaterial->getId()] = [$rawMaterial->getName(), $quantity, $quantity / 1000, $quantity / $pesoAmasada];
  633.             $costes['before']['amasada'][$rawMaterial->getId()] = [$rawMaterial->getName(), $quantity / $pesoAmasada, $rawMaterial->getPrice(), ($quantity / $pesoAmasada) * $rawMaterial->getPrice()];
  634.         }
  635.         //  $cookieOriginal = $cookie;
  637.         $projectCalcs->setIngredientesAmasada($cookie);
  638.         /** FIN INGREDIENTES DE LA MASA */
  640.         /** INGREDIENTES DE LA GALLETA */
  641.         // Creamos la receta combinando los distintos materiales de las recetas de horno
  642.         foreach ($recipesBeforeOvenCalcs as $id => $otherRecipe) {
  643.             if (isset($cookie[$id])) {
  644.                 $cookie[$id][1] += $otherRecipe[4];
  645.                 $cookie[$id][2] += $otherRecipe[5];
  646.             } else {
  647.                 $cookie[$id] = [$otherRecipe[0], $otherRecipe[4], $otherRecipe[5], $otherRecipe[3],];
  648.             }
  649.         }
  651.         $cookieOriginal = $cookie;
  653.         // Ahora calculamos el total de cada material quitándole la humedad
  654.         $sumaHorneado = 0;
  655.         $this->nutricionalCookie = new NutritionalInfo();
  656.         foreach($cookie as $idMaterialCookie => $materialCookie) {
  657.             $cookie[$idMaterialCookie][1] = ($materialCookie[1] * (100 - $MaterialesUsados[$idMaterialCookie]->getHumidity()) / 100) * ((100 - $MaterialesUsados[$idMaterialCookie]->getLostVolatilization()) / 100);
  658.             $cookie[$idMaterialCookie][2] = $cookie[$idMaterialCookie][1] / 1000;
  659.             $sumaHorneado += $cookie[$idMaterialCookie][1];
  660.         }
  661.         $projectHumidity = $project->getHumidity()/100;
  662.         $humedadHorneado = $projectHumidity * $sumaHorneado / (1 - $projectHumidity);
  664.         $totalHorneado = $sumaHorneado + $humedadHorneado;
  665.         foreach($cookie as $idMaterialCookie => $materialCookie) {
  666.             $cookie[$idMaterialCookie][3] = $materialCookie[1] / $totalHorneado;
  667.             //$cookie[$idMaterialCookie][3] = $cookie[$idMaterialCookie][1] / $totalHorneado;
  668.             $this->nutricionalCookie->addRawMaterial($MaterialesUsados[$idMaterialCookie], $cookie[$idMaterialCookie][3]);
  669.                 $cookie[$idMaterialCookie][4] = $cookieOriginal[$idMaterialCookie][1] / $totalHorneado;
  670.                 $cookie[$idMaterialCookie][5] = $cookieOriginal[$idMaterialCookie][1];
  671.         }
  672.         $projectCalcs->setIngredientesCookie($cookie);
  673.         /*echo "\n\n== AMASADA TERMINADA ==\n\n";
  674.         echo var_export($cookie, true);
  675.         echo "\n\n";*/
  676.         $perdidaEstimada = $pesoAmasada + array_reduce($pesoRelacionAmasada, fn($a,$r)=>$a+$r,0) - $totalHorneado;
  677.         if ($pesoAmasada === 0) {
  678.             $perdidaEstimadaPorcentaje = $perdidaEstimada;
  679.         }  else {
  680.             $perdidaEstimadaPorcentaje = $perdidaEstimada / $pesoAmasada;
  681.         }
  683.         $projectCalcs->setTotalPesoCookie(sprintf('%01.4f', $sumaHorneado / 1000)); // <- A kg
  684.         $projectCalcs->setHumedadHorneado(sprintf('%01.4f', $humedadHorneado / 1000)); // <- A kg
  685.         $projectCalcs->setTotalHorneado(sprintf('%01.4f', $totalHorneado / 1000)); // <- A Kg
  686.         $projectCalcs->setPerdidaEstimada(sprintf('%01.4f', $perdidaEstimada / 1000)); // <- A kg
  687.         $projectCalcs->setPerdidaEstimadaPorcentaje(sprintf('%01.5f', $perdidaEstimadaPorcentaje));
  688.         /** FIN INGREDIENTES DE LA GALLETA */
  691.         /** INGREDIENTES DESPUES DEL HORNO */
  692.         $afterOvenRecipeCalcs = [];
  693.         $costes['after'] = [];
  694.         $BDIngredientesDespuesHorno = [];
  696.         foreach ($afterOvenTests as $recipeKey => $recipeTest) {
  697.             $nombreTipo = $recipeTest->getRecipe()->getType();
  698.             $BDIngredientesDespuesHorno[$nombreTipo] = [];
  700.             $materials = $recipeTestRawMaterialRepository->findBy(['recipeTest' => $recipeTest]);
  701.             $recipeId = $recipeTest->getRecipe()->getId();
  702.             //$recipeName = $recipeTest->getRecipe()->getType();
  703.             $afterOvenRecipeCalcs[$recipeId] = [];
  704.             $costes['after'][$recipeKey] = [];
  705.             $this->nutricionalDespuesHorno[$recipeKey] = new NutritionalInfo();
  706.             $total = 0;
  707.             foreach ($materials as $material) {
  708.                 $rawMaterial = $material->getRawMaterial();
  709.                 if (!isset($MaterialesUsados[$rawMaterial->getId()])) {
  710.                     $MaterialesUsados[$rawMaterial->getId()] = $rawMaterial;
  711.                 }
  712.                 $quantity = $material->getQuantity();
  713.                 $afterOvenRecipeCalcs[$recipeId][$rawMaterial->getId()] = [$rawMaterial->getName(), $quantity, $quantity / 1000, 0];
  715.                 $total += $quantity;
  716.             }
  717.             array_walk($afterOvenRecipeCalcs[$recipeId], fn(&$r)=> $r[3] = isset($r[1]) ? ($r[1] / $total) : '');
  719.             foreach ($materials as $material) {
  720.                 $rawMaterial = $material->getRawMaterial();
  721.                 $quantity = $material->getQuantity();
  722.                 $costes['after'][$recipeKey][$rawMaterial->getId()] = [$rawMaterial->getName(), $quantity / $total, $rawMaterial->getPrice(), $rawMaterial->getPrice() * ($quantity / $total)];
  723.                 $this->nutricionalDespuesHorno[$recipeKey]->addRawMaterialWithoutHumidity($rawMaterial, $quantity / $total);
  724.             }
  725.             $BDIngredientesDespuesHorno[$recipeKey] = $afterOvenRecipeCalcs[$recipeId];
  726.         }
  728.         /*echo "\n\n== INGREDIENTES DESPUES HORNO ==\n\n";
  729.         var_export($BDIngredientesDespuesHorno);
  730.         echo "\n\n";*/
  732.         $projectCalcs->setIngredientesDespuesHorno($BDIngredientesDespuesHorno);
  733.         unset($BDIngredientesDespuesHorno);
  734.         /** FIN INGREDIENTES DESPUES DEL HORNO */
  736.         /** INGREDIENTES PRODUCTO TERMINADO */
  737.         $productoTerminado = [];
  739.         $cookiePercentage = 100 - array_reduce($afterOvenBakingPercentage, fn($a,$r)=>$a+$r, 0);
  740.         //echo "Porcentaje galleta: {$cookiePercentage}\n\n";
  741.         foreach($cookie as $idMaterialCookie => $materialCookie) {
  742.             $productoTerminado[$idMaterialCookie] = [
  743.                 $materialCookie[0],
  744.                 $materialCookie[3] * $cookiePercentage,
  745.                 isset($materialCookie[4]) ? $materialCookie[4] * $cookiePercentage : null,
  746.                 $materialCookie[1],
  747.                 $idMaterialCookie
  748.             ];
  749.         }
  751.         //var_dump($this->nutricionalCookie);
  752.         $nutricionalProductoFinal = new NutritionalInfo();
  753.         $nutricionalProductoFinal->addSimple($this->nutricionalCookie, $cookiePercentage / 100);
  754.         foreach ($afterOvenTests as $recipeKey => $recipeTest) {
  755.             $nutricionalProductoFinal->addSimple($this->nutricionalDespuesHorno[$recipeKey], $recipeTest->getRecipe()->getBaking() / 100);
  756.         }
  758.         //var_dump($this->nutricionalProductoFinal);
  760.         $key = 0;
  761.         foreach ($afterOvenRecipeCalcs as $recipe) {
  762.             foreach ($recipe as $materialId => $materialInfo) {
  763.                 if (!isset($productoTerminado[$materialId])) {
  764.                     $productoTerminado[$materialId] = [
  765.                         $materialInfo[0],
  766.                         $materialInfo[3] * $afterOvenBakingPercentage[$key],
  767.                         $materialInfo[3] * $afterOvenBakingPercentage[$key],
  768.                         $materialInfo[1],
  769.                         $materialId,
  770.                     ];
  771.                 } else {
  772.                     $productoTerminado[$materialId][1] += $materialInfo[3] * $afterOvenBakingPercentage[$key];
  773.                     $productoTerminado[$materialId][2] += $materialInfo[3] * $afterOvenBakingPercentage[$key];
  774.                 }
  775.             }
  776.             $key++;
  777.         }
  778.         $projectCalcs->setHumedadGalleta(sprintf('%01.4f', $projectHumidity * $cookiePercentage));
  780.         /*foreach ($productoTerminado as $materialId => $lineaMaterial) {
  781.             echo "Añadir material {$MaterialesUsados[$materialId]->getName()} {$MaterialesUsados[$materialId]->getGrease()} {$lineaMaterial[1]}\n";
  782.             //$this->nutricionalProductoFinal->addRawMaterialWithHumidity($MaterialesUsados[$materialId], $lineaMaterial[1] / 100);
  783.         }*/
  785.         $projectCalcs->setIngredientesProductoTerminado($productoTerminado);
  787.         /*echo "\n\n== INGREDIENTES PRODUCTO TERMINADO ==\n\n";
  788.         var_export($productoTerminado);
  789.         echo "\n\n";*/
  791.         /** FIN INGREDIENTES PRODUCTO TERMINADO */
  793.         /** COSTES AMASADA */
  794.         $recipeTotalCost = array_reduce($costes['before']['amasada'], fn($a,$r) => $a + $r[3], 0);
  795.         $recipeKneadingCost = $recipeTotalCost * $J17;
  796.         //$projectCalcs->setCosteAmasada(sprintf('%01.4f', $recipeTotalCost));
  798.         $projectCalcs->setCostesAmasada($costes['before']['amasada']);
  799.         /** FIN COSTES AMASADA */
  801.         /** COSTES ANTES HORNO */
  802.         $key = 0;
  803.         $BDCostesAntesHorno = [];
  804.         foreach ($costes['before']['others'] as $recipeType => $recipeCosts) {
  805.             $recipeTotalCosts = array_reduce($recipeCosts, fn($a,$r) => $a + $r[3], 0);
  806.             $BDCostesAntesHorno[$recipeType] = $recipeTotalCosts;
  807.             $recipeKneadingCost += $recipeTotalCosts * $porcentajesRecetas[$key];
  808.             $key++;
  809.         }
  810.         $projectCalcs->setCostesAntesHorno($BDCostesAntesHorno);
  811.         //$projectCalcs->setCosteAmasada(sprintf('%01.4f', $recipeKneadingCost));
  812.         unset($BDCostesAntesHorno);
  813.         /** FIN COSTES ANTES HORNO */
  815.         $totalKneadingCost = $recipeKneadingCost * ($pesoAmasada + array_reduce($pesoRelacionAmasada, fn($a,$k)=>$a + $k, 0)) / $totalHorneado;
  816.         $totalProductCost = $totalKneadingCost * ($cookiePercentage / 100);
  817.         $projectCalcs->setCosteAmasada(sprintf('%01.4f', $totalKneadingCost));
  819.         /** COSTES DESPUES HORNO */
  820.         $key = 0;
  821.         $BDCostesDespuesHorno = []; //var_dump($costes['after']);
  822.         foreach ($costes['after'] as $recipeKey => $recipeCosts) {
  823.             $recipeTotalCosts = array_reduce($recipeCosts, fn($a,$r) => $a + $r[3], 0);
  824.             $totalProductCost += $recipeTotalCosts * ($afterOvenBakingPercentage[$key] / 100);
  825.             $BDCostesDespuesHorno[$recipeKey] = $recipeCosts;
  826.             $key++;
  827.         }
  828.         $projectCalcs->setCostesDespuesHorno($BDCostesDespuesHorno);
  829.         unset($BDCostesDespuesHorno);
  830.         /** FIN COSTES DESPUES HORNO */
  832.         $projectCalcs->setCosteProductoTerminado(sprintf('%01.4f',$totalProductCost));
  834.         $projectCalcs
  835.             ->setInformacionNutricionalCookie($this->nutricionalCookie->result())
  836.             ->setCdrCookie($this->nutricionalCookie->cdr())
  837.             ->setNutriscoreCookie($this->nutricionalCookie->nutriscore($entityManager));
  839.         /*$nutricionalDespues = [];
  840.         $cdrDespues = [];
  841.         $nutriscoreDespues = [];
  842.         foreach ($this->nutricionalDespuesHorno as $tipo => $nutricional) {
  843.             $nutricionalDespues[$tipo] = $nutricional->result();
  844.             $cdrDespues[$tipo] = $nutricional->cdr();
  845.             $nutriscoreDespues[$tipo] = $nutricional->nutriscore($entityManager);
  846.         }
  847.         $projectCalcs
  848.             ->setInformacionNutricionalDespuesHorno($nutricionalDespues)
  849.             ->setCdrDespuesHorno($cdrDespues)
  850.             ->setNutriscoreDespuesHorno($nutriscoreDespues);
  851.         unset($nutricionalDespues);
  852.         unset($cdrDespues);
  853.         unset($nutriscoreDespues);*/
  855.         //var_dump($this->nutricionalProductoFinal->result());
  856.         $projectCalcs->setInformacionNutricionalProducto($nutricionalProductoFinal->result());
  857.         //$projectCalcs->setInformacionNutricionalProductoAjustado($this->nutricionalProductoFinal->result());
  858.         $projectCalcs->setCdrProducto($nutricionalProductoFinal->cdr());
  859.         $nutriscoreFinal = $nutricionalProductoFinal->nutriscore($entityManager);
  860.         $projectCalcs->setNutriscoreProducto($nutriscoreFinal);
  861.         $projectCalcs->setNutriscoreProductoValor(array_values(array_filter($nutriscoreFinal, fn($r) => $r['key'] === 'Nutriscore'))[0]['value']);
  862.         $projectCalcs->setNutriscoreProductoLetra(array_values(array_filter($nutriscoreFinal, fn($r) => $r['key'] === 'Nutriscore_letter'))[0]['value']);
  864.         $entityManager->persist($projectCalcs);
  865.         $entityManager->persist($project);
  866.         $entityManager->flush();
  868.         return new JsonResponse([
  869.             'nutriscore' => $nutriscoreFinal,
  870.             //'j' => $this->nutricionalProductoFinal->result(),
  871.             'id_calculo' => $projectCalcs->getId(),
  872.         ]);
  873.     }
  874. }