mirror of
https://github.com/Part-DB/Part-DB-server.git
synced 2026-01-13 05:39:33 +00:00
306 lines
9.5 KiB
PHP
306 lines
9.5 KiB
PHP
<?php
|
|
|
|
declare(strict_types=1);
|
|
|
|
/*
|
|
* This file is part of Part-DB (https://github.com/Part-DB/Part-DB-symfony).
|
|
*
|
|
* Copyright (C) 2019 - 2023 Jan Böhmer (https://github.com/jbtronics)
|
|
*
|
|
* This program is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU Affero General Public License as published
|
|
* by the Free Software Foundation, either version 3 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU Affero General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Affero General Public License
|
|
* along with this program. If not, see <https://www.gnu.org/licenses/>.
|
|
*/
|
|
namespace App\Helpers\Assemblies;
|
|
|
|
use App\Entity\Parts\Part;
|
|
use App\Entity\Parts\PartLot;
|
|
use App\Entity\AssemblySystem\Assembly;
|
|
use App\Entity\AssemblySystem\AssemblyBOMEntry;
|
|
use App\Validator\Constraints\AssemblySystem\ValidAssemblyBuildRequest;
|
|
|
|
/**
|
|
* @see \App\Tests\Helpers\Assemblies\AssemblyBuildRequestTest
|
|
*/
|
|
#[ValidAssemblyBuildRequest]
|
|
final class AssemblyBuildRequest
|
|
{
|
|
private readonly int $number_of_builds;
|
|
|
|
/**
|
|
* @var array<int, float>
|
|
*/
|
|
private array $withdraw_amounts = [];
|
|
|
|
private string $comment = '';
|
|
|
|
private ?PartLot $builds_lot = null;
|
|
|
|
private bool $add_build_to_builds_part = false;
|
|
|
|
private bool $dont_check_quantity = false;
|
|
|
|
/**
|
|
* @param Assembly $assembly The assembly that should be build
|
|
* @param int $number_of_builds The number of builds that should be created
|
|
*/
|
|
public function __construct(private readonly Assembly $assembly, int $number_of_builds)
|
|
{
|
|
if ($number_of_builds < 1) {
|
|
throw new \InvalidArgumentException('Number of builds must be at least 1!');
|
|
}
|
|
$this->number_of_builds = $number_of_builds;
|
|
|
|
$this->initializeArray();
|
|
|
|
//By default, use the first available lot of builds part if there is one.
|
|
if($assembly->getBuildPart() instanceof Part) {
|
|
$this->add_build_to_builds_part = true;
|
|
foreach( $assembly->getBuildPart()->getPartLots() as $lot) {
|
|
if (!$lot->isInstockUnknown()) {
|
|
$this->builds_lot = $lot;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private function initializeArray(): void
|
|
{
|
|
//Completely reset the array
|
|
$this->withdraw_amounts = [];
|
|
|
|
//Now create an array for each BOM entry
|
|
foreach ($this->getPartBomEntries() as $bom_entry) {
|
|
$remaining_amount = $this->getNeededAmountForBOMEntry($bom_entry);
|
|
foreach($this->getPartLotsForBOMEntry($bom_entry) as $lot) {
|
|
//If the lot has instock use it for the build
|
|
$this->withdraw_amounts[$lot->getID()] = min($remaining_amount, $lot->getAmount());
|
|
$remaining_amount -= max(0, $this->withdraw_amounts[$lot->getID()]);
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Ensure that the assemblyBOMEntry belongs to the assembly, otherwise throw an exception.
|
|
*/
|
|
private function ensureBOMEntryValid(AssemblyBOMEntry $entry): void
|
|
{
|
|
if ($entry->getAssembly() !== $this->assembly) {
|
|
throw new \InvalidArgumentException('The given BOM entry does not belong to the assembly!');
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Returns the partlot where the builds should be added to, or null if it should not be added to any lot.
|
|
*/
|
|
public function getBuildsPartLot(): ?PartLot
|
|
{
|
|
return $this->builds_lot;
|
|
}
|
|
|
|
/**
|
|
* Return if the builds should be added to the builds part of this assembly as new stock
|
|
*/
|
|
public function getAddBuildsToBuildsPart(): bool
|
|
{
|
|
return $this->add_build_to_builds_part;
|
|
}
|
|
|
|
/**
|
|
* Set if the builds should be added to the builds part of this assembly as new stock
|
|
* @return $this
|
|
*/
|
|
public function setAddBuildsToBuildsPart(bool $new_value): self
|
|
{
|
|
$this->add_build_to_builds_part = $new_value;
|
|
|
|
if ($new_value === false) {
|
|
$this->builds_lot = null;
|
|
}
|
|
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* Set the partlot where the builds should be added to, or null if it should not be added to any lot.
|
|
* The part lot must belong to the assembly build part, or an exception is thrown!
|
|
* @return $this
|
|
*/
|
|
public function setBuildsPartLot(?PartLot $new_part_lot): self
|
|
{
|
|
//Ensure that this new_part_lot belongs to the assembly
|
|
if (($new_part_lot instanceof PartLot && $new_part_lot->getPart() !== $this->assembly->getBuildPart()) || !$this->assembly->getBuildPart() instanceof Part) {
|
|
throw new \InvalidArgumentException('The given part lot does not belong to the assemblies build part!');
|
|
}
|
|
|
|
if ($new_part_lot instanceof PartLot) {
|
|
$this->setAddBuildsToBuildsPart(true);
|
|
}
|
|
|
|
$this->builds_lot = $new_part_lot;
|
|
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* Returns the comment where the user can write additional information about the build.
|
|
*/
|
|
public function getComment(): string
|
|
{
|
|
return $this->comment;
|
|
}
|
|
|
|
/**
|
|
* Sets the comment where the user can write additional information about the build.
|
|
*/
|
|
public function setComment(string $comment): void
|
|
{
|
|
$this->comment = $comment;
|
|
}
|
|
|
|
/**
|
|
* Returns the amount of parts that should be withdrawn from the given lot for the corresponding BOM entry.
|
|
* @param PartLot|int $lot The part lot (or the ID of the part lot) for which the withdrawal amount should be got
|
|
*/
|
|
public function getLotWithdrawAmount(PartLot|int $lot): float
|
|
{
|
|
$lot_id = $lot instanceof PartLot ? $lot->getID() : $lot;
|
|
|
|
if (! array_key_exists($lot_id, $this->withdraw_amounts)) {
|
|
throw new \InvalidArgumentException('The given lot is not in the withdraw amounts array!');
|
|
}
|
|
|
|
return $this->withdraw_amounts[$lot_id];
|
|
}
|
|
|
|
/**
|
|
* Sets the amount of parts that should be withdrawn from the given lot for the corresponding BOM entry.
|
|
* @param PartLot|int $lot The part lot (or the ID of the part lot) for which the withdrawal amount should be got
|
|
* @return $this
|
|
*/
|
|
public function setLotWithdrawAmount(PartLot|int $lot, float $amount): self
|
|
{
|
|
if ($lot instanceof PartLot) {
|
|
$lot_id = $lot->getID();
|
|
} elseif (is_int($lot)) {
|
|
$lot_id = $lot;
|
|
} else {
|
|
throw new \InvalidArgumentException('The given lot must be an instance of PartLot or an ID of a PartLot!');
|
|
}
|
|
|
|
$this->withdraw_amounts[$lot_id] = $amount;
|
|
|
|
return $this;
|
|
}
|
|
|
|
/**
|
|
* Returns the sum of all withdraw amounts for the given BOM entry.
|
|
*/
|
|
public function getWithdrawAmountSum(AssemblyBOMEntry $entry): float
|
|
{
|
|
$this->ensureBOMEntryValid($entry);
|
|
|
|
$sum = 0;
|
|
foreach ($this->getPartLotsForBOMEntry($entry) as $lot) {
|
|
$sum += $this->getLotWithdrawAmount($lot);
|
|
}
|
|
|
|
if ($entry->getPart() && !$entry->getPart()->useFloatAmount()) {
|
|
$sum = round($sum);
|
|
}
|
|
|
|
return $sum;
|
|
}
|
|
|
|
/**
|
|
* Returns the number of available lots to take stock from for the given BOM entry.
|
|
* @return PartLot[]|null Returns null if the entry is a non-part BOM entry
|
|
*/
|
|
public function getPartLotsForBOMEntry(AssemblyBOMEntry $assemblyBOMEntry): ?array
|
|
{
|
|
$this->ensureBOMEntryValid($assemblyBOMEntry);
|
|
|
|
if (!$assemblyBOMEntry->getPart() instanceof Part) {
|
|
return null;
|
|
}
|
|
|
|
//Filter out all lots which have unknown instock
|
|
return $assemblyBOMEntry->getPart()->getPartLots()->filter(fn (PartLot $lot) => !$lot->isInstockUnknown())->toArray();
|
|
}
|
|
|
|
/**
|
|
* Returns the needed amount of parts for the given BOM entry.
|
|
*/
|
|
public function getNeededAmountForBOMEntry(AssemblyBOMEntry $entry): float
|
|
{
|
|
$this->ensureBOMEntryValid($entry);
|
|
|
|
return $entry->getQuantity() * $this->number_of_builds;
|
|
}
|
|
|
|
/**
|
|
* Returns the list of all bom entries.
|
|
* @return AssemblyBOMEntry[]
|
|
*/
|
|
public function getBomEntries(): array
|
|
{
|
|
return $this->assembly->getBomEntries()->toArray();
|
|
}
|
|
|
|
/**
|
|
* Returns all part bom entries.
|
|
* @return AssemblyBOMEntry[]
|
|
*/
|
|
public function getPartBomEntries(): array
|
|
{
|
|
return $this->assembly->getBomEntries()->filter(fn(AssemblyBOMEntry $entry) => $entry->isPartBomEntry())->toArray();
|
|
}
|
|
|
|
/**
|
|
* Returns which assembly should be build
|
|
*/
|
|
public function getAssembly(): Assembly
|
|
{
|
|
return $this->assembly;
|
|
}
|
|
|
|
/**
|
|
* Returns the number of builds that should be created.
|
|
*/
|
|
public function getNumberOfBuilds(): int
|
|
{
|
|
return $this->number_of_builds;
|
|
}
|
|
|
|
/**
|
|
* If Set to true, the given withdraw amounts are used without any checks for requirements.
|
|
* @return bool
|
|
*/
|
|
public function isDontCheckQuantity(): bool
|
|
{
|
|
return $this->dont_check_quantity;
|
|
}
|
|
|
|
/**
|
|
* Set to true, the given withdraw amounts are used without any checks for requirements.
|
|
* @param bool $dont_check_quantity
|
|
* @return $this
|
|
*/
|
|
public function setDontCheckQuantity(bool $dont_check_quantity): AssemblyBuildRequest
|
|
{
|
|
$this->dont_check_quantity = $dont_check_quantity;
|
|
return $this;
|
|
}
|
|
|
|
|
|
}
|