ColonyLibFactory::getCommodityCache() - Code Metrics - Inspection of "added commodity cache" - st-universe/core - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — dev ( 766009...bcc49c )

by Janko

created 2023-06-15 10:06 UTC

ColonyLibFactory::getCommodityCache() A

↳ Parent: Project

Complexity

Conditions	2
Paths	2

Size

Total Lines	7
Code Lines	3

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	6

Importance

Changes

Metric	Value
cc	2
eloc	3
nc	2
nop	0
dl	0
loc	7
ccs	0
cts	4
cp	0
crap	6
rs	10
c	0
b	0
f	0

<?php

declare(strict_types=1);

namespace Stu\Module\Colony\Lib;

use Doctrine\ORM\EntityManagerInterface;
use Stu\Component\Colony\ColonyFunctionManagerInterface;
use Stu\Component\Colony\ColonyPopulationCalculator;
use Stu\Component\Colony\ColonyPopulationCalculatorInterface;
use Stu\Component\Colony\Commodity\ColonyCommodityProduction;
use Stu\Component\Colony\Commodity\ColonyCommodityProductionInterface;
use Stu\Component\Colony\Commodity\ColonyProductionSumReducer;
use Stu\Component\Colony\Commodity\ColonyProductionSumReducerInterface;
use Stu\Component\Colony\Shields\ColonyShieldingManager;
use Stu\Component\Colony\Shields\ColonyShieldingManagerInterface;
use Stu\Lib\ColonyProduction\ColonyProduction;
use Stu\Lib\ModuleScreen\Addon\ModuleSelectorAddonFactoryInterface;
use Stu\Lib\ModuleScreen\ModuleSelector;
use Stu\Lib\ModuleScreen\ModuleSelectorSpecial;
use Stu\Module\Commodity\Lib\CommodityCacheInterface;
use Stu\Module\Logging\LoggerUtilFactoryInterface;
use Stu\Module\Tal\TalPageInterface;
use Stu\Orm\Entity\ColonyInterface;
use Stu\Orm\Entity\CommodityInterface;
use Stu\Orm\Entity\ShipBuildplanInterface;
use Stu\Orm\Entity\ShipInterface;
use Stu\Orm\Entity\ShipRumpInterface;
use Stu\Orm\Entity\UserInterface;
use Stu\Orm\Repository\BuildingCommodityRepositoryInterface;
use Stu\Orm\Repository\BuildingRepositoryInterface;
use Stu\Orm\Repository\ColonyRepositoryInterface;
use Stu\Orm\Repository\FlightSignatureRepositoryInterface;
use Stu\Orm\Repository\ModuleRepositoryInterface;
use Stu\Orm\Repository\PlanetFieldRepositoryInterface;
use Stu\Orm\Repository\ResearchedRepositoryInterface;
use Stu\Orm\Repository\ShipBuildplanRepositoryInterface;
use Stu\Orm\Repository\ShipRepositoryInterface;
use Stu\Orm\Repository\ShipRumpModuleLevelRepositoryInterface;
use Stu\PlanetGenerator\PlanetGeneratorInterface;

final class ColonyLibFactory implements ColonyLibFactoryInterface
{
    private PlanetFieldRepositoryInterface $planetFieldRepository;

    private BuildingRepositoryInterface $buildingRepository;

    private ColonyRepositoryInterface $colonyRepository;

    private CommodityConsumptionInterface $commodityConsumption;

    private ShipRepositoryInterface $shipRepository;

    private ShipBuildplanRepositoryInterface $shipBuildplanRepository;

    private ResearchedRepositoryInterface $researchedRepository;

    private FlightSignatureRepositoryInterface $flightSignatureRepository;

    private PlanetGeneratorInterface $planetGenerator;

    private EntityManagerInterface $entityManager;

    private BuildingCommodityRepositoryInterface $buildingCommodityRepository;

    private ModuleRepositoryInterface $moduleRepository;

    private ShipRumpModuleLevelRepositoryInterface $shipRumpModuleLevelRepository;

    private TalPageInterface $talPage;

    private PlanetFieldTypeRetrieverInterface $planetFieldTypeRetriever;

    private ColonyFunctionManagerInterface $colonyFunctionManager;

    private ModuleSelectorAddonFactoryInterface $moduleSelectorAddonFactory;

    private CommodityCacheInterface $commodityCache;

    private LoggerUtilFactoryInterface $loggerUtilFactory;

    public function __construct(
        PlanetFieldRepositoryInterface $planetFieldRepository,
        BuildingRepositoryInterface $buildingRepository,
        ColonyRepositoryInterface $colonyRepository,
        CommodityConsumptionInterface $commodityConsumption,
        ShipRepositoryInterface $shipRepository,
        ShipBuildplanRepositoryInterface $shipBuildplanRepository,
        ResearchedRepositoryInterface $researchedRepository,
        FlightSignatureRepositoryInterface $flightSignatureRepository,
        PlanetGeneratorInterface $planetGenerator,
        EntityManagerInterface $entityManager,
        BuildingCommodityRepositoryInterface $buildingCommodityRepository,
        ModuleRepositoryInterface $moduleRepository,
        ShipRumpModuleLevelRepositoryInterface $shipRumpModuleLevelRepository,
        TalPageInterface $talPage,
        PlanetFieldTypeRetrieverInterface $planetFieldTypeRetriever,
        ColonyFunctionManagerInterface $colonyFunctionManager,
        ModuleSelectorAddonFactoryInterface $moduleSelectorAddonFactory,
        CommodityCacheInterface $commodityCache,
        LoggerUtilFactoryInterface $loggerUtilFactory
    ) {
        $this->planetFieldRepository = $planetFieldRepository;
        $this->buildingRepository = $buildingRepository;
        $this->colonyRepository = $colonyRepository;
        $this->commodityConsumption = $commodityConsumption;
        $this->shipRepository = $shipRepository;
        $this->shipBuildplanRepository = $shipBuildplanRepository;
        $this->researchedRepository = $researchedRepository;
        $this->flightSignatureRepository = $flightSignatureRepository;
        $this->planetGenerator = $planetGenerator;
        $this->entityManager = $entityManager;
        $this->buildingCommodityRepository = $buildingCommodityRepository;
        $this->moduleRepository = $moduleRepository;
        $this->shipRumpModuleLevelRepository = $shipRumpModuleLevelRepository;
        $this->talPage = $talPage;
        $this->planetFieldTypeRetriever = $planetFieldTypeRetriever;
        $this->colonyFunctionManager = $colonyFunctionManager;
        $this->moduleSelectorAddonFactory = $moduleSelectorAddonFactory;
        $this->commodityCache = $commodityCache;
        $this->loggerUtilFactory = $loggerUtilFactory;
    }

    public function createBuildingFunctionTal(
        array $buildingFunctionIds
    ): BuildingFunctionTalInterface {
        return new BuildingFunctionTal($buildingFunctionIds);
    }

    public function createColonySurface(
        ColonyInterface $colony,
        ?int $buildingId = null,
        bool $showUnderground = true
    ): ColonySurfaceInterface {
        return new ColonySurface(
            $this,
            $this->planetFieldRepository,
            $this->buildingRepository,
            $this->colonyRepository,
            $this->researchedRepository,
            $this->planetGenerator,
            $this->entityManager,
            $this->loggerUtilFactory->getLoggerUtil(),
            $this->planetFieldTypeRetriever,
            $colony,
            $buildingId,
            $showUnderground
        );
    }

    public function createColonyListItem(
        ColonyInterface $colony
    ): ColonyListItemInterface {
        return new ColonyListItem(
            $this,
            $this->planetFieldRepository,
            $this->commodityConsumption,
            $colony,
            $this->flightSignatureRepository->getVisibleSignatureCount($colony)
        );
    }

    public function createBuildableRumpItem(
        ShipRumpInterface $shipRump,
        UserInterface $currentUser
    ): BuildableRumpListItemInterface {
        return new BuildableRumpListItem(
            $this->shipRepository,
            $this->shipBuildplanRepository,
            $shipRump,
            $currentUser
        );
    }

    public function createColonyProductionPreviewWrapper(
        array $production
    ): ColonyProductionPreviewWrapper {
        return new ColonyProductionPreviewWrapper(
            $this,
            $this->buildingCommodityRepository,
            $production
        );
    }

    public function createEpsProductionPreviewWrapper(
        ColonyInterface $colony
    ): ColonyEpsProductionPreviewWrapper {
        return new ColonyEpsProductionPreviewWrapper(
            $this->planetFieldRepository,
            $this->buildingRepository,
            $colony
        );
    }

    public function createModuleSelector(
        int $moduleType,
        ?ColonyInterface $colony,
        ?ShipInterface $station,
        ShipRumpInterface $rump,
        int $userId,
        ?ShipBuildplanInterface $buildplan = null
    ): ModuleSelector {

        $addon = $this->moduleSelectorAddonFactory->createModuleSelectorAddon($moduleType);

        return new ModuleSelector(
            $this->moduleRepository,
            $this->shipRumpModuleLevelRepository,
            $this->talPage,
            $moduleType,
            $colony,
            $station,
            $rump,
            $userId,
            $addon,
            $buildplan
        );
    }

    public function createModuleSelectorSpecial(
        int $moduleType,
        ?ColonyInterface $colony,
        ?ShipInterface $station,
        ShipRumpInterface $rump,
        int $userId,
        ?ShipBuildplanInterface $buildplan = null
    ): ModuleSelectorSpecial {
        return new ModuleSelectorSpecial(
            $this->moduleRepository,
            $this->shipRumpModuleLevelRepository,
            $this->talPage,
            $moduleType,
            $colony,
            $station,
            $rump,
            $userId,
            null,
            $buildplan
        );
    }

    public function createColonyProduction(
        CommodityInterface $commodity,
        int $production,
        ?int $pc = null
    ): ColonyProduction {
        return new ColonyProduction(
            $commodity,
            $production,
            $pc
        );
    }

    public function createColonyShieldingManager(
        ColonyInterface $colony
    ): ColonyShieldingManagerInterface {
        return new ColonyShieldingManager(
            $this->planetFieldRepository,
            $this->colonyFunctionManager,
            $colony
        );
    }

    public function createColonyCommodityProduction(
        ColonyInterface $colony
    ): ColonyCommodityProductionInterface {
        return new ColonyCommodityProduction(
            $this->buildingCommodityRepository,
            $colony,
            $this,
            $this->commodityCache
        );
    }

    public function createColonyProductionSumReducer(): ColonyProductionSumReducerInterface
    {
        return new ColonyProductionSumReducer();
    }

    public function createColonyPopulationCalculator(
        ColonyInterface $colony,
        array $production = null
    ): ColonyPopulationCalculatorInterface {

        return new ColonyPopulationCalculator(
            $colony,
            $production === null ? $this->createColonyCommodityProduction($colony)->getProduction() : $production
        );
    }
}


1			<?php
2
3			declare(strict_types=1);
4
5			namespace Stu\Module\Colony\Lib;
6
7			use Doctrine\ORM\EntityManagerInterface;
8			use Stu\Component\Colony\ColonyFunctionManagerInterface;
9			use Stu\Component\Colony\ColonyPopulationCalculator;
10			use Stu\Component\Colony\ColonyPopulationCalculatorInterface;
11			use Stu\Component\Colony\Commodity\ColonyCommodityProduction;
12			use Stu\Component\Colony\Commodity\ColonyCommodityProductionInterface;
13			use Stu\Component\Colony\Commodity\ColonyProductionSumReducer;
14			use Stu\Component\Colony\Commodity\ColonyProductionSumReducerInterface;
15			use Stu\Component\Colony\Shields\ColonyShieldingManager;
16			use Stu\Component\Colony\Shields\ColonyShieldingManagerInterface;
17			use Stu\Lib\ColonyProduction\ColonyProduction;
18			use Stu\Lib\ModuleScreen\Addon\ModuleSelectorAddonFactoryInterface;
19			use Stu\Lib\ModuleScreen\ModuleSelector;
20			use Stu\Lib\ModuleScreen\ModuleSelectorSpecial;
21			use Stu\Module\Commodity\Lib\CommodityCacheInterface;
22			use Stu\Module\Logging\LoggerUtilFactoryInterface;
23			use Stu\Module\Tal\TalPageInterface;
24			use Stu\Orm\Entity\ColonyInterface;
25			use Stu\Orm\Entity\CommodityInterface;
26			use Stu\Orm\Entity\ShipBuildplanInterface;
27			use Stu\Orm\Entity\ShipInterface;
28			use Stu\Orm\Entity\ShipRumpInterface;
29			use Stu\Orm\Entity\UserInterface;
30			use Stu\Orm\Repository\BuildingCommodityRepositoryInterface;
31			use Stu\Orm\Repository\BuildingRepositoryInterface;
32			use Stu\Orm\Repository\ColonyRepositoryInterface;
33			use Stu\Orm\Repository\FlightSignatureRepositoryInterface;
34			use Stu\Orm\Repository\ModuleRepositoryInterface;
35			use Stu\Orm\Repository\PlanetFieldRepositoryInterface;
36			use Stu\Orm\Repository\ResearchedRepositoryInterface;
37			use Stu\Orm\Repository\ShipBuildplanRepositoryInterface;
38			use Stu\Orm\Repository\ShipRepositoryInterface;
39			use Stu\Orm\Repository\ShipRumpModuleLevelRepositoryInterface;
40			use Stu\PlanetGenerator\PlanetGeneratorInterface;
41
42			final class ColonyLibFactory implements ColonyLibFactoryInterface
43			{
44			private PlanetFieldRepositoryInterface $planetFieldRepository;
45
46			private BuildingRepositoryInterface $buildingRepository;
47
48			private ColonyRepositoryInterface $colonyRepository;
49
50			private CommodityConsumptionInterface $commodityConsumption;
51
52			private ShipRepositoryInterface $shipRepository;
53
54			private ShipBuildplanRepositoryInterface $shipBuildplanRepository;
55
56			private ResearchedRepositoryInterface $researchedRepository;
57
58			private FlightSignatureRepositoryInterface $flightSignatureRepository;
59
60			private PlanetGeneratorInterface $planetGenerator;
61
62			private EntityManagerInterface $entityManager;
63
64			private BuildingCommodityRepositoryInterface $buildingCommodityRepository;
65
66			private ModuleRepositoryInterface $moduleRepository;
67
68			private ShipRumpModuleLevelRepositoryInterface $shipRumpModuleLevelRepository;
69
70			private TalPageInterface $talPage;
71
72			private PlanetFieldTypeRetrieverInterface $planetFieldTypeRetriever;
73
74			private ColonyFunctionManagerInterface $colonyFunctionManager;
75
76			private ModuleSelectorAddonFactoryInterface $moduleSelectorAddonFactory;
77
78			private CommodityCacheInterface $commodityCache;
79
80			private LoggerUtilFactoryInterface $loggerUtilFactory;
81
82			public function __construct(
83			PlanetFieldRepositoryInterface $planetFieldRepository,
84			BuildingRepositoryInterface $buildingRepository,
85			ColonyRepositoryInterface $colonyRepository,
86			CommodityConsumptionInterface $commodityConsumption,
87			ShipRepositoryInterface $shipRepository,
88			ShipBuildplanRepositoryInterface $shipBuildplanRepository,
89			ResearchedRepositoryInterface $researchedRepository,
90			FlightSignatureRepositoryInterface $flightSignatureRepository,
91			PlanetGeneratorInterface $planetGenerator,
92			EntityManagerInterface $entityManager,
93			BuildingCommodityRepositoryInterface $buildingCommodityRepository,
94			ModuleRepositoryInterface $moduleRepository,
95			ShipRumpModuleLevelRepositoryInterface $shipRumpModuleLevelRepository,
96			TalPageInterface $talPage,
97			PlanetFieldTypeRetrieverInterface $planetFieldTypeRetriever,
98			ColonyFunctionManagerInterface $colonyFunctionManager,
99			ModuleSelectorAddonFactoryInterface $moduleSelectorAddonFactory,
100			CommodityCacheInterface $commodityCache,
101			LoggerUtilFactoryInterface $loggerUtilFactory
102			) {
103			$this->planetFieldRepository = $planetFieldRepository;
104			$this->buildingRepository = $buildingRepository;
105			$this->colonyRepository = $colonyRepository;
106			$this->commodityConsumption = $commodityConsumption;
107			$this->shipRepository = $shipRepository;
108			$this->shipBuildplanRepository = $shipBuildplanRepository;
109			$this->researchedRepository = $researchedRepository;
110			$this->flightSignatureRepository = $flightSignatureRepository;
111			$this->planetGenerator = $planetGenerator;
112			$this->entityManager = $entityManager;
113			$this->buildingCommodityRepository = $buildingCommodityRepository;
114			$this->moduleRepository = $moduleRepository;
115			$this->shipRumpModuleLevelRepository = $shipRumpModuleLevelRepository;
116			$this->talPage = $talPage;
117			$this->planetFieldTypeRetriever = $planetFieldTypeRetriever;
118			$this->colonyFunctionManager = $colonyFunctionManager;
119			$this->moduleSelectorAddonFactory = $moduleSelectorAddonFactory;
120			$this->commodityCache = $commodityCache;
121			$this->loggerUtilFactory = $loggerUtilFactory;
122			}
123
124			public function createBuildingFunctionTal(
125			array $buildingFunctionIds
126			): BuildingFunctionTalInterface {
127			return new BuildingFunctionTal($buildingFunctionIds);
128			}
129
130			public function createColonySurface(
131			ColonyInterface $colony,
132			?int $buildingId = null,
133			bool $showUnderground = true
134			): ColonySurfaceInterface {
135			return new ColonySurface(
136			$this,
137			$this->planetFieldRepository,
138			$this->buildingRepository,
139			$this->colonyRepository,
140			$this->researchedRepository,
141			$this->planetGenerator,
142			$this->entityManager,
143			$this->loggerUtilFactory->getLoggerUtil(),
144			$this->planetFieldTypeRetriever,
145			$colony,
146			$buildingId,
147			$showUnderground
148			);
149			}
150
151			public function createColonyListItem(
152			ColonyInterface $colony
153			): ColonyListItemInterface {
154			return new ColonyListItem(
155			$this,
156			$this->planetFieldRepository,
157			$this->commodityConsumption,
158			$colony,
159			$this->flightSignatureRepository->getVisibleSignatureCount($colony)
160			);
161			}
162
163			public function createBuildableRumpItem(
164			ShipRumpInterface $shipRump,
165			UserInterface $currentUser
166			): BuildableRumpListItemInterface {
167			return new BuildableRumpListItem(
168			$this->shipRepository,
169			$this->shipBuildplanRepository,
170			$shipRump,
171			$currentUser
172			);
173			}
174
175			public function createColonyProductionPreviewWrapper(
176			array $production
177			): ColonyProductionPreviewWrapper {
178			return new ColonyProductionPreviewWrapper(
179			$this,
180			$this->buildingCommodityRepository,
181			$production
182			);
183			}
184
185			public function createEpsProductionPreviewWrapper(
186			ColonyInterface $colony
187			): ColonyEpsProductionPreviewWrapper {
188			return new ColonyEpsProductionPreviewWrapper(
189			$this->planetFieldRepository,
190			$this->buildingRepository,
191			$colony
192			);
193			}
194
195			public function createModuleSelector(
196			int $moduleType,
197			?ColonyInterface $colony,
198			?ShipInterface $station,
199			ShipRumpInterface $rump,
200			int $userId,
201			?ShipBuildplanInterface $buildplan = null
202			): ModuleSelector {
203
204			$addon = $this->moduleSelectorAddonFactory->createModuleSelectorAddon($moduleType);
205
206			return new ModuleSelector(
207			$this->moduleRepository,
208			$this->shipRumpModuleLevelRepository,
209			$this->talPage,
210			$moduleType,
211			$colony,
212			$station,
213			$rump,
214			$userId,
215			$addon,
216			$buildplan
217			);
218			}
219
220			public function createModuleSelectorSpecial(
221			int $moduleType,
222			?ColonyInterface $colony,
223			?ShipInterface $station,
224			ShipRumpInterface $rump,
225			int $userId,
226			?ShipBuildplanInterface $buildplan = null
227			): ModuleSelectorSpecial {
228			return new ModuleSelectorSpecial(
229			$this->moduleRepository,
230			$this->shipRumpModuleLevelRepository,
231			$this->talPage,
232			$moduleType,
233			$colony,
234			$station,
235			$rump,
236			$userId,
237			null,
238			$buildplan
239			);
240			}
241
242			public function createColonyProduction(
243			CommodityInterface $commodity,
244			int $production,
245			?int $pc = null
246			): ColonyProduction {
247			return new ColonyProduction(
248			$commodity,
249			$production,
250			$pc
251			);
252			}
253
254			public function createColonyShieldingManager(
255			ColonyInterface $colony
256			): ColonyShieldingManagerInterface {
257			return new ColonyShieldingManager(
258			$this->planetFieldRepository,
259			$this->colonyFunctionManager,
260			$colony
261			);
262			}
263
264			public function createColonyCommodityProduction(
265			ColonyInterface $colony
266			): ColonyCommodityProductionInterface {
267			return new ColonyCommodityProduction(
268			$this->buildingCommodityRepository,
269			$colony,
270			$this,
271			$this->commodityCache
272			);
273			}
274
275			public function createColonyProductionSumReducer(): ColonyProductionSumReducerInterface
276			{
277			return new ColonyProductionSumReducer();
278			}
279
280			public function createColonyPopulationCalculator(
281			ColonyInterface $colony,
282			array $production = null
283			): ColonyPopulationCalculatorInterface {
284
285			return new ColonyPopulationCalculator(
286			$colony,
287			$production === null ? $this->createColonyCommodityProduction($colony)->getProduction() : $production
288			);
289			}
290			}
291

st-universe / core

Push — dev ( 766009...bcc49c )

ColonyLibFactory::getCommodityCache() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like