CreateBuildplan::__construct() - Code Metrics - Inspection of "Dev" - st-universe/core - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Pull Request — master (#1930)

by Janko

created 2024-11-14 19:41 UTC

CreateBuildplan::__construct() A

↳ Parent: Project

Complexity

Conditions	1
Paths	1

Size

Total Lines	22
Code Lines	10

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	2

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
cc	1
eloc	10
c	1
b	0
f	0
nc	1
nop	10
dl	0
loc	22
ccs	0
cts	11
cp	0
crap	2
rs	9.9332

How to fix Many Parameters

<?php

declare(strict_types=1);

namespace Stu\Module\NPC\Action;

use Override;
use Doctrine\ORM\EntityManagerInterface;
use RuntimeException;
use request;
use Stu\Component\Ship\Buildplan\BuildplanSignatureCreationInterface;
use Stu\Component\Ship\Crew\ShipCrewCalculatorInterface;
use Stu\Module\Control\ActionControllerInterface;
use Stu\Module\Control\GameControllerInterface;
use Stu\Orm\Repository\BuildplanModuleRepositoryInterface;
use Stu\Orm\Repository\ModuleRepositoryInterface;
use Stu\Orm\Repository\ShipBuildplanRepositoryInterface;
use Stu\Orm\Repository\ShipRumpModuleLevelRepositoryInterface;
use Stu\Orm\Repository\ShipRumpRepositoryInterface;
use Stu\Orm\Repository\UserRepositoryInterface;
use Stu\Module\ShipModule\ModuleSpecialAbilityEnum;
use Stu\Module\NPC\View\ShowBuildplanCreator\ShowBuildplanCreator;
use Stu\Orm\Repository\NPCLogRepositoryInterface;

final class CreateBuildplan implements ActionControllerInterface
{
    public const string ACTION_IDENTIFIER = 'B_CREATE_BUILDPLAN';


    public function __construct(
        private EntityManagerInterface $entityManager,
        private ShipRumpRepositoryInterface $shipRumpRepository,
        private ShipRumpModuleLevelRepositoryInterface $shipRumpModuleLevelRepository,
        private ModuleRepositoryInterface $moduleRepository,
        private ShipBuildplanRepositoryInterface $buildplanRepository,
        private BuildplanModuleRepositoryInterface $buildplanModuleRepository,
        private UserRepositoryInterface $userRepository,
        private ShipCrewCalculatorInterface $shipCrewCalculator,
        private BuildplanSignatureCreationInterface $buildplanSignatureCreation,
        private NPCLogRepositoryInterface $npcLogRepository
    ) {}

    #[Override]
    public function handle(GameControllerInterface $game): void
    {
        $game->setView(ShowBuildplanCreator::VIEW_IDENTIFIER);
        $userId = request::postIntFatal('userId');
        $rumpId = request::postIntFatal('rumpId');
        $moduleList = request::postArray('mod');
        $moduleSpecialList = request::postArray('special_mod');

        if (!$game->isAdmin() && !$game->isNpc()) {
            $game->addInformation(_('[b][color=#ff2626]Aktion nicht möglich, Spieler ist kein Admin/NPC![/color][/b]'));
            return;
        }

        $rump = $this->shipRumpRepository->find($rumpId);
        if ($rump === null) {
            throw new RuntimeException(sprintf('rumpId %d does not exist!', $rumpId));
        }

        $mod_level = $this->shipRumpModuleLevelRepository->getByShipRump($rump->getId());
        if ($mod_level === null) {
            throw new RuntimeException(sprintf('No module levels found for rump %d', $rump->getId()));
        }

        if (count($moduleList) < $mod_level->getMandatoryModulesCount()) {
            $game->addInformation('Nicht alle benötigten Module wurden ausgewählt');
            return;
        }

        $user = $this->userRepository->find($userId);
        if ($user === null) {
            throw new RuntimeException(sprintf('userId %d does not exist', $userId));
        }

        $moduleIds = array_merge($moduleList, $moduleSpecialList);
        $signature = $this->buildplanSignatureCreation->createSignatureByModuleIds(
            $moduleIds,
            0
        );

        $plan = $this->buildplanRepository->getByUserShipRumpAndSignature($userId, $rump->getId(), $signature);

        if ($plan === null) {
            $planname = sprintf(
                'Bauplan %s %s',
                $rump->getName(),
                date('d.m.Y H:i')
            );

            $plan = $this->buildplanRepository->prototype();
            $plan->setUser($user);
            $plan->setRump($rump);
            $plan->setName($planname);
            $plan->setSignature($signature);
            $plan->setBuildtime(0);

            $this->buildplanRepository->save($plan);
            $this->entityManager->flush();

            $modules = [];

            foreach ($moduleList as $moduleId) {
                $module = $this->moduleRepository->find($moduleId);
                if ($module === null) {
                    throw new RuntimeException(sprintf('moduleId %d does not exist', $moduleId));
                }

                $mod = $this->buildplanModuleRepository->prototype();
                $mod->setModuleType($module->getType());
                $mod->setBuildplan($plan);
                $mod->setModule($module);

                $modules[$moduleId] = $module;

                $this->buildplanModuleRepository->save($mod);
            }

            foreach ($moduleSpecialList as $moduleId) {
                $module = $this->moduleRepository->find($moduleId);
                if ($module === null) {
                    throw new RuntimeException(sprintf('moduleId %d does not exist', $moduleId));
                }

                $mod = $this->buildplanModuleRepository->prototype();
                $mod->setModuleType($module->getType());
                $mod->setBuildplan($plan);
                $mod->setModule($module);
                $mod->setModuleSpecial(ModuleSpecialAbilityEnum::getHash($module->getSpecials()));

                $modules[$moduleId] = $module;

                $this->buildplanModuleRepository->save($mod);
            }

            $crewInput = request::postInt('crew_input');

            if ($crewInput > 0) {
                $plan->setCrew($crewInput);
            } else {
                $plan->setCrew($this->shipCrewCalculator->getCrewUsage($modules, $rump, $user));
            }

            $this->buildplanRepository->save($plan);

            $this->entityManager->flush();

            $moduleNames = [];
            foreach ($modules as $module) {
                $moduleNames[] = $module->getName();
            }

            $reason = request::postString('reason');

            if ($reason === '') {
                $game->addInformation("Grund fehlt");
                return;
            }

            $logText = sprintf(
                '%s hat für Spieler %s (%s) einen Bauplan erstellt. Rumpf: %s, Module: %s, Crew: %d, Grund: %s',
                $game->getUser()->getName(),
                $user->getName(),
                $user->getId(),
                $rump->getName(),
                implode(', ', $moduleNames),
                $plan->getCrew(),
                $reason
            );

            $this->createLogEntry($logText, $game->getUser()->getId());

            $game->addInformation('Bauplan wurde erstellt');
        } else {
            $game->addInformation('Bauplan existiert bereits');
        }
    }

    public function createLogEntry(string $text, int $userId): void
    {
        $entry = $this->npcLogRepository->prototype();
        $entry->setText($text);
        $entry->setSourceUserId($userId);
        $entry->setDate(time());

        $this->npcLogRepository->save($entry);
    }

    #[Override]
    public function performSessionCheck(): bool
    {
        return true;
    }
}


1			<?php
2
3			declare(strict_types=1);
4
5			namespace Stu\Module\NPC\Action;
6
7			use Override;
8			use Doctrine\ORM\EntityManagerInterface;
9			use RuntimeException;
10			use request;
11			use Stu\Component\Ship\Buildplan\BuildplanSignatureCreationInterface;
12			use Stu\Component\Ship\Crew\ShipCrewCalculatorInterface;
13			use Stu\Module\Control\ActionControllerInterface;
14			use Stu\Module\Control\GameControllerInterface;
15			use Stu\Orm\Repository\BuildplanModuleRepositoryInterface;
16			use Stu\Orm\Repository\ModuleRepositoryInterface;
17			use Stu\Orm\Repository\ShipBuildplanRepositoryInterface;
18			use Stu\Orm\Repository\ShipRumpModuleLevelRepositoryInterface;
19			use Stu\Orm\Repository\ShipRumpRepositoryInterface;
20			use Stu\Orm\Repository\UserRepositoryInterface;
21			use Stu\Module\ShipModule\ModuleSpecialAbilityEnum;
22			use Stu\Module\NPC\View\ShowBuildplanCreator\ShowBuildplanCreator;
23			use Stu\Orm\Repository\NPCLogRepositoryInterface;
24
25			final class CreateBuildplan implements ActionControllerInterface
26			{
27			public const string ACTION_IDENTIFIER = 'B_CREATE_BUILDPLAN';
			0 ignored issues – show Bug introduced 2024-11-14 12:29 UTC by Report Bug Copy Issue Report A parse error occurred: Syntax error, unexpected T_STRING, expecting '=' on line 27 at column 24 Loading history...
28
29			public function __construct(
30			private EntityManagerInterface $entityManager,
31			private ShipRumpRepositoryInterface $shipRumpRepository,
32			private ShipRumpModuleLevelRepositoryInterface $shipRumpModuleLevelRepository,
33			private ModuleRepositoryInterface $moduleRepository,
34			private ShipBuildplanRepositoryInterface $buildplanRepository,
35			private BuildplanModuleRepositoryInterface $buildplanModuleRepository,
36			private UserRepositoryInterface $userRepository,
37			private ShipCrewCalculatorInterface $shipCrewCalculator,
38			private BuildplanSignatureCreationInterface $buildplanSignatureCreation,
39			private NPCLogRepositoryInterface $npcLogRepository
40			) {}
41
42			#[Override]
43			public function handle(GameControllerInterface $game): void
44			{
45			$game->setView(ShowBuildplanCreator::VIEW_IDENTIFIER);
46			$userId = request::postIntFatal('userId');
47			$rumpId = request::postIntFatal('rumpId');
48			$moduleList = request::postArray('mod');
49			$moduleSpecialList = request::postArray('special_mod');
50
51			if (!$game->isAdmin() && !$game->isNpc()) {
52			$game->addInformation(_('[b][color=#ff2626]Aktion nicht möglich, Spieler ist kein Admin/NPC![/color][/b]'));
53			return;
54			}
55
56			$rump = $this->shipRumpRepository->find($rumpId);
57			if ($rump === null) {
58			throw new RuntimeException(sprintf('rumpId %d does not exist!', $rumpId));
59			}
60
61			$mod_level = $this->shipRumpModuleLevelRepository->getByShipRump($rump->getId());
62			if ($mod_level === null) {
63			throw new RuntimeException(sprintf('No module levels found for rump %d', $rump->getId()));
64			}
65
66			if (count($moduleList) < $mod_level->getMandatoryModulesCount()) {
67			$game->addInformation('Nicht alle benötigten Module wurden ausgewählt');
68			return;
69			}
70
71			$user = $this->userRepository->find($userId);
72			if ($user === null) {
73			throw new RuntimeException(sprintf('userId %d does not exist', $userId));
74			}
75
76			$moduleIds = array_merge($moduleList, $moduleSpecialList);
77			$signature = $this->buildplanSignatureCreation->createSignatureByModuleIds(
78			$moduleIds,
79			0
80			);
81
82			$plan = $this->buildplanRepository->getByUserShipRumpAndSignature($userId, $rump->getId(), $signature);
83
84			if ($plan === null) {
85			$planname = sprintf(
86			'Bauplan %s %s',
87			$rump->getName(),
88			date('d.m.Y H:i')
89			);
90
91			$plan = $this->buildplanRepository->prototype();
92			$plan->setUser($user);
93			$plan->setRump($rump);
94			$plan->setName($planname);
95			$plan->setSignature($signature);
96			$plan->setBuildtime(0);
97
98			$this->buildplanRepository->save($plan);
99			$this->entityManager->flush();
100
101			$modules = [];
102
103			foreach ($moduleList as $moduleId) {
104			$module = $this->moduleRepository->find($moduleId);
105			if ($module === null) {
106			throw new RuntimeException(sprintf('moduleId %d does not exist', $moduleId));
107			}
108
109			$mod = $this->buildplanModuleRepository->prototype();
110			$mod->setModuleType($module->getType());
111			$mod->setBuildplan($plan);
112			$mod->setModule($module);
113
114			$modules[$moduleId] = $module;
115
116			$this->buildplanModuleRepository->save($mod);
117			}
118
119			foreach ($moduleSpecialList as $moduleId) {
120			$module = $this->moduleRepository->find($moduleId);
121			if ($module === null) {
122			throw new RuntimeException(sprintf('moduleId %d does not exist', $moduleId));
123			}
124
125			$mod = $this->buildplanModuleRepository->prototype();
126			$mod->setModuleType($module->getType());
127			$mod->setBuildplan($plan);
128			$mod->setModule($module);
129			$mod->setModuleSpecial(ModuleSpecialAbilityEnum::getHash($module->getSpecials()));
130
131			$modules[$moduleId] = $module;
132
133			$this->buildplanModuleRepository->save($mod);
134			}
135
136			$crewInput = request::postInt('crew_input');
137
138			if ($crewInput > 0) {
139			$plan->setCrew($crewInput);
140			} else {
141			$plan->setCrew($this->shipCrewCalculator->getCrewUsage($modules, $rump, $user));
142			}
143
144			$this->buildplanRepository->save($plan);
145
146			$this->entityManager->flush();
147
148			$moduleNames = [];
149			foreach ($modules as $module) {
150			$moduleNames[] = $module->getName();
151			}
152
153			$reason = request::postString('reason');
154
155			if ($reason === '') {
156			$game->addInformation("Grund fehlt");
157			return;
158			}
159
160			$logText = sprintf(
161			'%s hat für Spieler %s (%s) einen Bauplan erstellt. Rumpf: %s, Module: %s, Crew: %d, Grund: %s',
162			$game->getUser()->getName(),
163			$user->getName(),
164			$user->getId(),
165			$rump->getName(),
166			implode(', ', $moduleNames),
167			$plan->getCrew(),
168			$reason
169			);
170
171			$this->createLogEntry($logText, $game->getUser()->getId());
172
173			$game->addInformation('Bauplan wurde erstellt');
174			} else {
175			$game->addInformation('Bauplan existiert bereits');
176			}
177			}
178
179			public function createLogEntry(string $text, int $userId): void
180			{
181			$entry = $this->npcLogRepository->prototype();
182			$entry->setText($text);
183			$entry->setSourceUserId($userId);
184			$entry->setDate(time());
185
186			$this->npcLogRepository->save($entry);
187			}
188
189			#[Override]
190			public function performSessionCheck(): bool
191			{
192			return true;
193			}
194			}
195

st-universe / core

Pull Request — master (#1930)

CreateBuildplan::__construct() A

Complexity

Size

Duplication

Code Coverage

Importance

How to fix Many Parameters

Many Parameters

Duplication Side-by-Side

Filter issues like