[CLEANUP] The correct case must be used for standard PHP types in phpdoc
[Packages/TYPO3.CMS.git] / typo3 / sysext / extensionmanager / Classes / Utility / ListUtility.php
1 <?php
2 namespace TYPO3\CMS\Extensionmanager\Utility;
3
4 /*
5 * This file is part of the TYPO3 CMS project.
6 *
7 * It is free software; you can redistribute it and/or modify it under
8 * the terms of the GNU General Public License, either version 2
9 * of the License, or any later version.
10 *
11 * For the full copyright and license information, please read the
12 * LICENSE.txt file that was distributed with this source code.
13 *
14 * The TYPO3 project - inspiring people to share!
15 */
16
17 use TYPO3\CMS\Core\Package\PackageInterface;
18 use TYPO3\CMS\Core\Utility\ExtensionManagementUtility;
19 use TYPO3\CMS\Core\Utility\GeneralUtility;
20 use TYPO3\CMS\Core\Utility\VersionNumberUtility;
21 use TYPO3\CMS\Extensionmanager\Domain\Model\Extension;
22
23 /**
24 * Utility for dealing with extension list related functions
25 *
26 * @TODO: Refactor this API class:
27 * - The methods depend on each other, they take each others result, that could be done internally
28 * - There is no good wording to distinguish existing and loaded extensions
29 * - The name 'listUtility' is not good, the methods could be moved to some 'extensionInformationUtility', or a repository?
30 */
31 class ListUtility implements \TYPO3\CMS\Core\SingletonInterface
32 {
33 /**
34 * @var \TYPO3\CMS\Extensionmanager\Utility\EmConfUtility
35 */
36 protected $emConfUtility;
37
38 /**
39 * @var \TYPO3\CMS\Extensionmanager\Domain\Repository\ExtensionRepository
40 */
41 protected $extensionRepository;
42
43 /**
44 * @var \TYPO3\CMS\Extensionmanager\Utility\InstallUtility
45 */
46 protected $installUtility;
47
48 /**
49 * @var \TYPO3\CMS\Core\Package\PackageManager
50 */
51 protected $packageManager;
52
53 /**
54 * @var \TYPO3\CMS\Extbase\SignalSlot\Dispatcher
55 */
56 protected $signalSlotDispatcher;
57
58 /**
59 * @var array
60 */
61 protected $availableExtensions = null;
62
63 /**
64 * @param \TYPO3\CMS\Extensionmanager\Utility\EmConfUtility $emConfUtility
65 */
66 public function injectEmConfUtility(\TYPO3\CMS\Extensionmanager\Utility\EmConfUtility $emConfUtility)
67 {
68 $this->emConfUtility = $emConfUtility;
69 }
70
71 /**
72 * @param \TYPO3\CMS\Extensionmanager\Domain\Repository\ExtensionRepository $extensionRepository
73 */
74 public function injectExtensionRepository(\TYPO3\CMS\Extensionmanager\Domain\Repository\ExtensionRepository $extensionRepository)
75 {
76 $this->extensionRepository = $extensionRepository;
77 }
78
79 /**
80 * @param \TYPO3\CMS\Extensionmanager\Utility\InstallUtility $installUtility
81 */
82 public function injectInstallUtility(\TYPO3\CMS\Extensionmanager\Utility\InstallUtility $installUtility)
83 {
84 $this->installUtility = $installUtility;
85 }
86
87 /**
88 * @param \TYPO3\CMS\Core\Package\PackageManager $packageManager
89 */
90 public function injectPackageManager(\TYPO3\CMS\Core\Package\PackageManager $packageManager)
91 {
92 $this->packageManager = $packageManager;
93 }
94
95 /**
96 * @param \TYPO3\CMS\Extbase\SignalSlot\Dispatcher $signalSlotDispatcher
97 */
98 public function injectSignalSlotDispatcher(\TYPO3\CMS\Extbase\SignalSlot\Dispatcher $signalSlotDispatcher)
99 {
100 $this->signalSlotDispatcher = $signalSlotDispatcher;
101 }
102
103 /**
104 * Returns the list of available, but not necessarily loaded extensions
105 *
106 * @return array[] All extensions with info
107 */
108 public function getAvailableExtensions()
109 {
110 if ($this->availableExtensions === null) {
111 $this->availableExtensions = [];
112 $this->emitPackagesMayHaveChangedSignal();
113 foreach ($this->packageManager->getAvailablePackages() as $package) {
114 $installationType = $this->getInstallTypeForPackage($package);
115 $this->availableExtensions[$package->getPackageKey()] = [
116 'siteRelPath' => str_replace(PATH_site, '', $package->getPackagePath()),
117 'type' => $installationType,
118 'key' => $package->getPackageKey(),
119 'ext_icon' => ExtensionManagementUtility::getExtensionIcon($package->getPackagePath()),
120 ];
121 }
122 }
123
124 return $this->availableExtensions;
125 }
126
127 /**
128 * Reset and reload the available extensions
129 */
130 public function reloadAvailableExtensions()
131 {
132 $this->availableExtensions = null;
133 $this->packageManager->scanAvailablePackages();
134 $this->getAvailableExtensions();
135 }
136
137 /**
138 * @param string $extensionKey
139 * @return \TYPO3\CMS\Core\Package\PackageInterface
140 * @throws \TYPO3\CMS\Core\Package\Exception\UnknownPackageException if the specified package is unknown
141 */
142 public function getExtension($extensionKey)
143 {
144 return $this->packageManager->getPackage($extensionKey);
145 }
146
147 /**
148 * Emits packages may have changed signal
149 */
150 protected function emitPackagesMayHaveChangedSignal()
151 {
152 $this->signalSlotDispatcher->dispatch('PackageManagement', 'packagesMayHaveChanged');
153 }
154
155 /**
156 * Returns "System", "Global" or "Local" based on extension position in filesystem.
157 *
158 * @param PackageInterface $package
159 * @return string
160 */
161 protected function getInstallTypeForPackage(PackageInterface $package)
162 {
163 foreach (Extension::returnInstallPaths() as $installType => $installPath) {
164 if (GeneralUtility::isFirstPartOfStr($package->getPackagePath(), $installPath)) {
165 return $installType;
166 }
167 }
168 return '';
169 }
170
171 /**
172 * Enrich the output of getAvailableExtensions() with an array key installed = 1 if an extension is loaded.
173 *
174 * @param array $availableExtensions
175 * @return array
176 */
177 public function getAvailableAndInstalledExtensions(array $availableExtensions)
178 {
179 foreach ($this->packageManager->getActivePackages() as $extKey => $_) {
180 if (isset($availableExtensions[$extKey])) {
181 $availableExtensions[$extKey]['installed'] = true;
182 }
183 }
184 return $availableExtensions;
185 }
186
187 /**
188 * Adds the information from the emconf array to the extension information
189 *
190 * @param array $extensions
191 * @return array
192 */
193 public function enrichExtensionsWithEmConfInformation(array $extensions)
194 {
195 foreach ($extensions as $extensionKey => $properties) {
196 $emconf = $this->emConfUtility->includeEmConf($properties);
197 if ($emconf) {
198 $extensions[$extensionKey] = array_merge($emconf, $properties);
199 } else {
200 unset($extensions[$extensionKey]);
201 }
202 }
203 return $extensions;
204 }
205
206 /**
207 * Adds the information from the emconf array and TER to the extension information
208 *
209 * @param array $extensions
210 * @return array
211 */
212 public function enrichExtensionsWithEmConfAndTerInformation(array $extensions)
213 {
214 $extensions = $this->enrichExtensionsWithEmConfInformation($extensions);
215 foreach ($extensions as $extensionKey => $properties) {
216 $terObject = $this->getExtensionTerData($extensionKey, $extensions[$extensionKey]['version']);
217 if ($terObject !== null) {
218 $extensions[$extensionKey]['terObject'] = $terObject;
219 $extensions[$extensionKey]['updateAvailable'] = false;
220 $extensions[$extensionKey]['updateToVersion'] = null;
221 $extensionToUpdate = $this->installUtility->getUpdateableVersion($terObject);
222 if ($extensionToUpdate !== false) {
223 $extensions[$extensionKey]['updateAvailable'] = true;
224 $extensions[$extensionKey]['updateToVersion'] = $extensionToUpdate;
225 }
226 }
227 }
228 return $extensions;
229 }
230
231 /**
232 * Tries to find given extension with given version in TER data.
233 * If extension is found but not the given version, we return TER data from highest version with version data set to
234 * given one.
235 *
236 * @param string $extensionKey Key of the extension
237 * @param string $version String representation of version number
238 * @return Extension|null Extension TER object or NULL if nothing found
239 */
240 protected function getExtensionTerData($extensionKey, $version)
241 {
242 $terObject = $this->extensionRepository->findOneByExtensionKeyAndVersion($extensionKey, $version);
243 if (!$terObject instanceof Extension) {
244 // Version unknown in TER data, try to find extension
245 $terObject = $this->extensionRepository->findHighestAvailableVersion($extensionKey);
246 if ($terObject instanceof Extension) {
247 // Found in TER now, set version information to the known ones, so we can look if there is a newer one
248 // Use a cloned object, otherwise wrong information is stored in persistenceManager
249 $terObject = clone $terObject;
250 $terObject->setVersion($version);
251 $terObject->setIntegerVersion(
252 VersionNumberUtility::convertVersionNumberToInteger($terObject->getVersion())
253 );
254 } else {
255 $terObject = null;
256 }
257 }
258
259 return $terObject;
260 }
261
262 /**
263 * Adds information about icon size to the extension information
264 *
265 * @param array $extensions
266 * @return array
267 */
268 public function enrichExtensionsWithIconInformation(array $extensions)
269 {
270 foreach ($extensions as &$properties) {
271 $iInfo = @getimagesize(PATH_site . $properties['siteRelPath'] . $properties['ext_icon']);
272 if ($iInfo !== false) {
273 $properties['ext_icon_width'] = $iInfo[0];
274 $properties['ext_icon_height'] = $iInfo[1];
275 } else {
276 $properties['ext_icon_width'] = 0;
277 $properties['ext_icon_height'] = 0;
278 }
279 }
280 unset($properties);
281 return $extensions;
282 }
283
284 /**
285 * Gets all available and installed extension with additional information
286 * from em_conf and TER (if available)
287 *
288 * @return array
289 */
290 public function getAvailableAndInstalledExtensionsWithAdditionalInformation()
291 {
292 $availableExtensions = $this->getAvailableExtensions();
293 $availableAndInstalledExtensions = $this->getAvailableAndInstalledExtensions($availableExtensions);
294 $availableAndInstalledExtensions = $this->enrichExtensionsWithIconInformation($availableAndInstalledExtensions);
295 return $this->enrichExtensionsWithEmConfAndTerInformation($availableAndInstalledExtensions);
296 }
297 }