symphonycms /
symphony-2
| Total Complexity | 140 |
| Total Lines | 1067 |
| Duplicated Lines | 0 % |
| Changes | 3 | ||
| Bugs | 1 | Features | 0 |
Complex classes like ExtensionManager often do a lot of different things. To break such a class down, we need to identify a cohesive component within that class. A common approach to find such a component is to look for fields/methods that share the same prefixes, or suffixes.
Once you have determined the fields that belong together, you can apply the Extract Class refactoring. If the component makes sense as a sub-class, Extract Subclass is also a candidate, and is often faster.
While breaking up the class, it is a good idea to analyze how other classes use ExtensionManager, and based on these observations, apply Extract Interface, too.
| 1 | <?php |
||
| 13 | class ExtensionManager implements FileResource |
||
| 14 | { |
||
| 15 | /** |
||
| 16 | * An array of all the objects that the Manager is responsible for. |
||
| 17 | * Defaults to an empty array. |
||
| 18 | * @var array |
||
| 19 | */ |
||
| 20 | protected static $_pool = array(); |
||
| 21 | |||
| 22 | /** |
||
| 23 | * An array of all extensions whose status is enabled |
||
| 24 | * @var array |
||
| 25 | */ |
||
| 26 | private static $_enabled_extensions = array(); |
||
| 27 | |||
| 28 | /** |
||
| 29 | * An array of all the subscriptions to Symphony delegates made by extensions. |
||
| 30 | * @var array |
||
| 31 | */ |
||
| 32 | private static $_subscriptions = array(); |
||
| 33 | |||
| 34 | /** |
||
| 35 | * An associative array of all the extensions in `tbl_extensions` where |
||
| 36 | * the key is the extension name and the value is an array |
||
| 37 | * representation of it's accompanying database row. |
||
| 38 | * @var array |
||
| 39 | */ |
||
| 40 | private static $_extensions = array(); |
||
| 41 | |||
| 42 | /** |
||
| 43 | * An associative array of all the providers from the enabled extensions. |
||
| 44 | * The key is the type of object, with the value being an associative array |
||
| 45 | * with the name, classname and path to the object |
||
| 46 | * |
||
| 47 | * @since Symphony 2.3 |
||
| 48 | * @var array |
||
| 49 | */ |
||
| 50 | private static $_providers = array(); |
||
| 51 | |||
| 52 | /** |
||
| 53 | * The constructor will populate the `$_subscriptions` variable from |
||
| 54 | * the `tbl_extension` and `tbl_extensions_delegates` tables. |
||
| 55 | */ |
||
| 56 | public function __construct() |
||
| 57 | { |
||
| 58 | if (empty(self::$_subscriptions) && Symphony::Database()->isConnected()) { |
||
| 59 | $subscriptions = Symphony::Database()->fetch( |
||
| 60 | "SELECT t1.name, t2.page, t2.delegate, t2.callback |
||
| 61 | FROM `tbl_extensions` as t1 INNER JOIN `tbl_extensions_delegates` as t2 ON t1.id = t2.extension_id |
||
| 62 | WHERE t1.status = 'enabled' |
||
| 63 | ORDER BY t2.delegate, t1.name" |
||
| 64 | ); |
||
| 65 | |||
| 66 | foreach ($subscriptions as $subscription) { |
||
| 67 | self::$_subscriptions[$subscription['delegate']][] = $subscription; |
||
| 68 | } |
||
| 69 | } |
||
| 70 | } |
||
| 71 | |||
| 72 | public static function __getHandleFromFilename($filename) |
||
| 73 | { |
||
| 74 | return false; |
||
| 75 | } |
||
| 76 | |||
| 77 | /** |
||
| 78 | * Given a name, returns the full class name of an Extension. |
||
| 79 | * Extension use an 'extension' prefix. |
||
| 80 | * |
||
| 81 | * @param string $name |
||
| 82 | * The extension handle |
||
| 83 | * @return string |
||
| 84 | */ |
||
| 85 | public static function __getClassName($name) |
||
| 86 | { |
||
| 87 | return 'extension_' . $name; |
||
| 88 | } |
||
| 89 | |||
| 90 | /** |
||
| 91 | * Finds an Extension by name by searching the `EXTENSIONS` folder and |
||
| 92 | * returns the path to the folder. |
||
| 93 | * |
||
| 94 | * @param string $name |
||
| 95 | * The extension folder |
||
| 96 | * @return string |
||
| 97 | */ |
||
| 98 | public static function __getClassPath($name) |
||
| 99 | { |
||
| 100 | return EXTENSIONS . strtolower("/$name"); |
||
|
Bug
introduced
by
|
|||
| 101 | } |
||
| 102 | |||
| 103 | /** |
||
| 104 | * Given a name, return the path to the driver of the Extension. |
||
| 105 | * |
||
| 106 | * @see toolkit.ExtensionManager#__getClassPath() |
||
| 107 | * @param string $name |
||
| 108 | * The extension folder |
||
| 109 | * @return string |
||
| 110 | */ |
||
| 111 | public static function __getDriverPath($name) |
||
| 112 | { |
||
| 113 | return self::__getClassPath($name) . '/extension.driver.php'; |
||
| 114 | } |
||
| 115 | |||
| 116 | /** |
||
| 117 | * This function returns an instance of an extension from it's name |
||
| 118 | * |
||
| 119 | * @param string $name |
||
| 120 | * The name of the Extension Class minus the extension prefix. |
||
| 121 | * @throws SymphonyErrorPage |
||
| 122 | * @throws Exception |
||
| 123 | * @return Extension |
||
| 124 | */ |
||
| 125 | public static function getInstance($name) |
||
| 126 | { |
||
| 127 | return (isset(self::$_pool[$name]) ? self::$_pool[$name] : self::create($name)); |
||
| 128 | } |
||
| 129 | |||
| 130 | /** |
||
| 131 | * Populates the `ExtensionManager::$_extensions` array with all the |
||
| 132 | * extensions stored in `tbl_extensions`. If `ExtensionManager::$_extensions` |
||
| 133 | * isn't empty, passing true as a parameter will force the array to update |
||
| 134 | * |
||
| 135 | * @param boolean $update |
||
| 136 | * Updates the `ExtensionManager::$_extensions` array even if it was |
||
| 137 | * populated, defaults to false. |
||
| 138 | * @throws DatabaseException |
||
| 139 | */ |
||
| 140 | private static function __buildExtensionList($update = false) |
||
| 141 | { |
||
| 142 | if (empty(self::$_extensions) || $update) { |
||
| 143 | self::$_extensions = Symphony::Database()->fetch("SELECT * FROM `tbl_extensions`", 'name'); |
||
| 144 | } |
||
| 145 | } |
||
| 146 | |||
| 147 | /** |
||
| 148 | * Returns the status of an Extension given an associative array containing |
||
| 149 | * the Extension `handle` and `version` where the `version` is the file |
||
| 150 | * version, not the installed version. This function returns an array |
||
| 151 | * which may include a maximum of two statuses. |
||
| 152 | * |
||
| 153 | * @param array $about |
||
| 154 | * An associative array of the extension meta data, typically returned |
||
| 155 | * by `ExtensionManager::about()`. At the very least this array needs |
||
| 156 | * `handle` and `version` keys. |
||
| 157 | * @return array |
||
| 158 | * An array of extension statuses, with the possible values being |
||
| 159 | * `EXTENSION_ENABLED`, `EXTENSION_DISABLED`, `EXTENSION_REQUIRES_UPDATE` |
||
| 160 | * or `EXTENSION_NOT_INSTALLED`. If an extension doesn't exist, |
||
| 161 | * `EXTENSION_NOT_INSTALLED` will be returned. |
||
| 162 | */ |
||
| 163 | public static function fetchStatus($about) |
||
| 164 | { |
||
| 165 | $return = array(); |
||
| 166 | self::__buildExtensionList(); |
||
| 167 | |||
| 168 | if (isset($about['handle']) && array_key_exists($about['handle'], self::$_extensions)) { |
||
| 169 | if (self::$_extensions[$about['handle']]['status'] == 'enabled') { |
||
| 170 | $return[] = Extension::EXTENSION_ENABLED; |
||
| 171 | } else { |
||
| 172 | $return[] = Extension::EXTENSION_DISABLED; |
||
| 173 | } |
||
| 174 | } else { |
||
| 175 | $return[] = Extension::EXTENSION_NOT_INSTALLED; |
||
| 176 | } |
||
| 177 | |||
| 178 | if (isset($about['handle'], $about['version']) && self::__requiresUpdate($about['handle'], $about['version'])) { |
||
| 179 | $return[] = Extension::EXTENSION_REQUIRES_UPDATE; |
||
| 180 | } |
||
| 181 | |||
| 182 | return $return; |
||
| 183 | } |
||
| 184 | |||
| 185 | /** |
||
| 186 | * A convenience method that returns an extension version from it's name. |
||
| 187 | * |
||
| 188 | * @param string $name |
||
| 189 | * The name of the Extension Class minus the extension prefix. |
||
| 190 | * @return string |
||
| 191 | */ |
||
| 192 | public static function fetchInstalledVersion($name) |
||
| 193 | { |
||
| 194 | self::__buildExtensionList(); |
||
| 195 | |||
| 196 | return (isset(self::$_extensions[$name]) ? self::$_extensions[$name]['version'] : null); |
||
| 197 | } |
||
| 198 | |||
| 199 | /** |
||
| 200 | * A convenience method that returns an extension ID from it's name. |
||
| 201 | * |
||
| 202 | * @param string $name |
||
| 203 | * The name of the Extension Class minus the extension prefix. |
||
| 204 | * @return integer |
||
| 205 | */ |
||
| 206 | public static function fetchExtensionID($name) |
||
| 207 | { |
||
| 208 | self::__buildExtensionList(); |
||
| 209 | |||
| 210 | return self::$_extensions[$name]['id']; |
||
| 211 | } |
||
| 212 | |||
| 213 | /** |
||
| 214 | * Return an array all the Provider objects supplied by extensions, |
||
| 215 | * optionally filtered by a given `$type`. |
||
| 216 | * |
||
| 217 | * @since Symphony 2.3 |
||
| 218 | * @todo Add information about the possible types |
||
| 219 | * @param string $type |
||
| 220 | * This will only return Providers of this type. If null, which is |
||
| 221 | * default, all providers will be returned. |
||
| 222 | * @throws Exception |
||
| 223 | * @throws SymphonyErrorPage |
||
| 224 | * @return array |
||
| 225 | * An array of objects |
||
| 226 | */ |
||
| 227 | public static function getProvidersOf($type = null) |
||
| 228 | { |
||
| 229 | // Loop over all extensions and build an array of providable objects |
||
| 230 | if (empty(self::$_providers)) { |
||
| 231 | self::$_providers = array(); |
||
| 232 | |||
| 233 | foreach (self::listInstalledHandles() as $handle) { |
||
| 234 | $obj = self::getInstance($handle); |
||
| 235 | |||
| 236 | if (!method_exists($obj, 'providerOf')) { |
||
| 237 | continue; |
||
| 238 | } |
||
| 239 | |||
| 240 | $providers = $obj->providerOf(); |
||
| 241 | |||
| 242 | if (empty($providers)) { |
||
| 243 | continue; |
||
| 244 | } |
||
| 245 | |||
| 246 | // For each of the matching objects (by $type), resolve the object path |
||
| 247 | self::$_providers = array_merge_recursive(self::$_providers, $obj->providerOf()); |
||
| 248 | } |
||
| 249 | } |
||
| 250 | |||
| 251 | // Return an array of objects |
||
| 252 | if (is_null($type)) { |
||
| 253 | return self::$_providers; |
||
| 254 | } |
||
| 255 | |||
| 256 | if (!isset(self::$_providers[$type])) { |
||
| 257 | return array(); |
||
| 258 | } |
||
| 259 | |||
| 260 | return self::$_providers[$type]; |
||
| 261 | } |
||
| 262 | |||
| 263 | /** |
||
| 264 | * This function will return the `Cacheable` object with the appropriate |
||
| 265 | * caching layer for the given `$key`. This `$key` should be stored in |
||
| 266 | * the Symphony configuration in the caching group with a reference |
||
| 267 | * to the class of the caching object. If the key is not found, this |
||
| 268 | * will return a default `Cacheable` object created with the MySQL driver. |
||
| 269 | * |
||
| 270 | * @since Symphony 2.4 |
||
| 271 | * @param string $key |
||
| 272 | * Should be a reference in the Configuration file to the Caching class |
||
| 273 | * @param boolean $reuse |
||
| 274 | * By default true, which will reuse an existing Cacheable object of `$key` |
||
| 275 | * if it exists. If false, a new instance will be generated. |
||
| 276 | * @return Cacheable |
||
| 277 | */ |
||
| 278 | public static function getCacheProvider($key = null, $reuse = true) |
||
| 279 | { |
||
| 280 | $cacheDriver = Symphony::Configuration()->get($key, 'caching'); |
||
| 281 | |||
| 282 | if (in_array($cacheDriver, array_keys(Symphony::ExtensionManager()->getProvidersOf('cache')))) { |
||
| 283 | $cacheable = new $cacheDriver; |
||
| 284 | } else { |
||
| 285 | $cacheable = Symphony::Database(); |
||
| 286 | $cacheDriver = 'CacheDatabase'; |
||
| 287 | } |
||
| 288 | |||
| 289 | if ($reuse === false) { |
||
| 290 | return new Cacheable($cacheable); |
||
| 291 | } elseif (!isset(self::$_pool[$cacheDriver])) { |
||
| 292 | self::$_pool[$cacheDriver] = new Cacheable($cacheable); |
||
| 293 | } |
||
| 294 | |||
| 295 | return self::$_pool[$cacheDriver]; |
||
| 296 | } |
||
| 297 | |||
| 298 | /** |
||
| 299 | * Determines whether the current extension is installed or not by checking |
||
| 300 | * for an id in `tbl_extensions` |
||
| 301 | * |
||
| 302 | * @param string $name |
||
| 303 | * The name of the Extension Class minus the extension prefix. |
||
| 304 | * @return boolean |
||
| 305 | */ |
||
| 306 | private static function __requiresInstallation($name) |
||
| 307 | { |
||
| 308 | self::__buildExtensionList(); |
||
| 309 | $id = self::$_extensions[$name]['id']; |
||
| 310 | |||
| 311 | return (is_numeric($id) ? false : true); |
||
| 312 | } |
||
| 313 | |||
| 314 | /** |
||
| 315 | * Determines whether an extension needs to be updated or not using |
||
| 316 | * PHP's `version_compare` function. This function will return the |
||
| 317 | * installed version if the extension requires an update, or |
||
| 318 | * false otherwise. |
||
| 319 | * |
||
| 320 | * @param string $name |
||
| 321 | * The name of the Extension Class minus the extension prefix. |
||
| 322 | * @param string $file_version |
||
| 323 | * The version of the extension from the **file**, not the Database. |
||
| 324 | * @return string|boolean |
||
| 325 | * If the given extension (by $name) requires updating, the installed |
||
| 326 | * version is returned, otherwise, if the extension doesn't require |
||
| 327 | * updating, false. |
||
| 328 | */ |
||
| 329 | private static function __requiresUpdate($name, $file_version) |
||
| 330 | { |
||
| 331 | $installed_version = self::fetchInstalledVersion($name); |
||
| 332 | |||
| 333 | if (is_null($installed_version)) { |
||
| 334 | return false; |
||
| 335 | } |
||
| 336 | |||
| 337 | return (version_compare($installed_version, $file_version, '<') ? $installed_version : false); |
||
| 338 | } |
||
| 339 | |||
| 340 | /** |
||
| 341 | * Enabling an extension will re-register all it's delegates with Symphony. |
||
| 342 | * It will also install or update the extension if needs be by calling the |
||
| 343 | * extensions respective install and update methods. The enable method is |
||
| 344 | * of the extension object is finally called. |
||
| 345 | * |
||
| 346 | * @see toolkit.ExtensionManager#registerDelegates() |
||
| 347 | * @see toolkit.ExtensionManager#__canUninstallOrDisable() |
||
| 348 | * @param string $name |
||
| 349 | * The name of the Extension Class minus the extension prefix. |
||
| 350 | * @throws SymphonyErrorPage |
||
| 351 | * @throws Exception |
||
| 352 | * @return boolean |
||
| 353 | */ |
||
| 354 | public static function enable($name) |
||
| 355 | { |
||
| 356 | $obj = self::getInstance($name); |
||
| 357 | |||
| 358 | // If not installed, install it |
||
| 359 | if (self::__requiresInstallation($name) && $obj->install() === false) { |
||
| 360 | // If the installation failed, run the uninstall method which |
||
| 361 | // should rollback the install method. #1326 |
||
| 362 | $obj->uninstall(); |
||
| 363 | return false; |
||
| 364 | |||
| 365 | // If the extension requires updating before enabling, then update it |
||
| 366 | } elseif (($about = self::about($name)) && ($previousVersion = self::__requiresUpdate($name, $about['version'])) !== false) { |
||
| 367 | $obj->update($previousVersion); |
||
| 368 | } |
||
| 369 | |||
| 370 | if (!isset($about)) { |
||
| 371 | $about = self::about($name); |
||
| 372 | } |
||
| 373 | |||
| 374 | $id = self::fetchExtensionID($name); |
||
| 375 | |||
| 376 | $fields = array( |
||
| 377 | 'name' => $name, |
||
| 378 | 'status' => 'enabled', |
||
| 379 | 'version' => $about['version'] |
||
| 380 | ); |
||
| 381 | |||
| 382 | // If there's no $id, the extension needs to be installed |
||
| 383 | if (is_null($id)) { |
||
| 384 | Symphony::Database()->insert($fields, 'tbl_extensions'); |
||
| 385 | self::__buildExtensionList(true); |
||
| 386 | |||
| 387 | // Extension is installed, so update! |
||
| 388 | } else { |
||
| 389 | Symphony::Database()->update($fields, 'tbl_extensions', sprintf(" `id` = %d ", $id)); |
||
| 390 | } |
||
| 391 | |||
| 392 | self::registerDelegates($name); |
||
| 393 | |||
| 394 | // Now enable the extension |
||
| 395 | $obj->enable(); |
||
| 396 | |||
| 397 | return true; |
||
| 398 | } |
||
| 399 | |||
| 400 | /** |
||
| 401 | * Disabling an extension will prevent it from executing but retain all it's |
||
| 402 | * settings in the relevant tables. Symphony checks that an extension can |
||
| 403 | * be disabled using the `canUninstallorDisable()` before removing |
||
| 404 | * all delegate subscriptions from the database and calling the extension's |
||
| 405 | * `disable()` function. |
||
| 406 | * |
||
| 407 | * @see toolkit.ExtensionManager#removeDelegates() |
||
| 408 | * @see toolkit.ExtensionManager#__canUninstallOrDisable() |
||
| 409 | * @param string $name |
||
| 410 | * The name of the Extension Class minus the extension prefix. |
||
| 411 | * @throws DatabaseException |
||
| 412 | * @throws SymphonyErrorPage |
||
| 413 | * @throws Exception |
||
| 414 | * @return boolean |
||
| 415 | */ |
||
| 416 | public static function disable($name) |
||
| 417 | { |
||
| 418 | $obj = self::getInstance($name); |
||
| 419 | |||
| 420 | self::__canUninstallOrDisable($obj); |
||
| 421 | |||
| 422 | $info = self::about($name); |
||
| 423 | $id = self::fetchExtensionID($name); |
||
| 424 | |||
| 425 | Symphony::Database()->update( |
||
| 426 | array( |
||
| 427 | 'name' => $name, |
||
| 428 | 'status' => 'disabled', |
||
| 429 | 'version' => $info['version'] |
||
| 430 | ), |
||
| 431 | 'tbl_extensions', |
||
| 432 | sprintf(" `id` = %d ", $id) |
||
| 433 | ); |
||
| 434 | |||
| 435 | $obj->disable(); |
||
| 436 | |||
| 437 | self::removeDelegates($name); |
||
| 438 | |||
| 439 | return true; |
||
| 440 | } |
||
| 441 | |||
| 442 | /** |
||
| 443 | * Uninstalling an extension will unregister all delegate subscriptions and |
||
| 444 | * remove all extension settings. Symphony checks that an extension can |
||
| 445 | * be uninstalled using the `canUninstallorDisable()` before calling |
||
| 446 | * the extension's `uninstall()` function. Alternatively, if this function |
||
| 447 | * is called because the extension described by `$name` cannot be found |
||
| 448 | * it's delegates and extension meta information will just be removed from the |
||
| 449 | * database. |
||
| 450 | * |
||
| 451 | * @see toolkit.ExtensionManager#removeDelegates() |
||
| 452 | * @see toolkit.ExtensionManager#__canUninstallOrDisable() |
||
| 453 | * @param string $name |
||
| 454 | * The name of the Extension Class minus the extension prefix. |
||
| 455 | * @throws Exception |
||
| 456 | * @throws SymphonyErrorPage |
||
| 457 | * @throws DatabaseException |
||
| 458 | * @throws Exception |
||
| 459 | * @return boolean |
||
| 460 | */ |
||
| 461 | public static function uninstall($name) |
||
| 462 | { |
||
| 463 | // If this function is called because the extension doesn't exist, |
||
| 464 | // then catch the error and just remove from the database. This |
||
| 465 | // means that the uninstall() function will not run on the extension, |
||
| 466 | // which may be a blessing in disguise as no entry data will be removed |
||
| 467 | try { |
||
| 468 | $obj = self::getInstance($name); |
||
| 469 | self::__canUninstallOrDisable($obj); |
||
| 470 | $obj->uninstall(); |
||
| 471 | } catch (SymphonyErrorPage $ex) { |
||
| 472 | // Create a consistant key |
||
| 473 | $key = str_replace('-', '_', $ex->getTemplateName()); |
||
| 474 | |||
| 475 | if ($key !== 'missing_extension') { |
||
| 476 | throw $ex; |
||
| 477 | } |
||
| 478 | } |
||
| 479 | |||
| 480 | self::removeDelegates($name); |
||
| 481 | Symphony::Database()->delete('tbl_extensions', sprintf(" `name` = '%s' ", $name)); |
||
| 482 | |||
| 483 | return true; |
||
| 484 | } |
||
| 485 | |||
| 486 | /** |
||
| 487 | * This functions registers an extensions delegates in `tbl_extensions_delegates`. |
||
| 488 | * |
||
| 489 | * @param string $name |
||
| 490 | * The name of the Extension Class minus the extension prefix. |
||
| 491 | * @throws Exception |
||
| 492 | * @throws SymphonyErrorPage |
||
| 493 | * @return integer |
||
| 494 | * The Extension ID |
||
| 495 | */ |
||
| 496 | public static function registerDelegates($name) |
||
| 497 | { |
||
| 498 | $obj = self::getInstance($name); |
||
| 499 | $id = self::fetchExtensionID($name); |
||
| 500 | |||
| 501 | if (!$id) { |
||
| 502 | return false; |
||
| 503 | } |
||
| 504 | |||
| 505 | Symphony::Database()->delete('tbl_extensions_delegates', sprintf(" |
||
| 506 | `extension_id` = %d ", $id |
||
| 507 | )); |
||
| 508 | |||
| 509 | $delegates = $obj->getSubscribedDelegates(); |
||
| 510 | |||
| 511 | if (is_array($delegates) && !empty($delegates)) { |
||
| 512 | foreach ($delegates as $delegate) { |
||
| 513 | Symphony::Database()->insert( |
||
| 514 | array( |
||
| 515 | 'extension_id' => $id, |
||
| 516 | 'page' => $delegate['page'], |
||
| 517 | 'delegate' => $delegate['delegate'], |
||
| 518 | 'callback' => $delegate['callback'] |
||
| 519 | ), |
||
| 520 | 'tbl_extensions_delegates' |
||
| 521 | ); |
||
| 522 | } |
||
| 523 | } |
||
| 524 | |||
| 525 | // Remove the unused DB records |
||
| 526 | self::cleanupDatabase(); |
||
| 527 | |||
| 528 | return $id; |
||
| 529 | } |
||
| 530 | |||
| 531 | /** |
||
| 532 | * This function will remove all delegate subscriptions for an extension |
||
| 533 | * given an extension's name. This triggers `cleanupDatabase()` |
||
| 534 | * |
||
| 535 | * @see toolkit.ExtensionManager#cleanupDatabase() |
||
| 536 | * @param string $name |
||
| 537 | * The name of the Extension Class minus the extension prefix. |
||
| 538 | * @return boolean |
||
| 539 | */ |
||
| 540 | public static function removeDelegates($name) |
||
| 541 | { |
||
| 542 | $delegates = Symphony::Database()->fetchCol('id', sprintf(" |
||
| 543 | SELECT tbl_extensions_delegates.`id` |
||
| 544 | FROM `tbl_extensions_delegates` |
||
| 545 | LEFT JOIN `tbl_extensions` |
||
| 546 | ON (`tbl_extensions`.id = `tbl_extensions_delegates`.extension_id) |
||
| 547 | WHERE `tbl_extensions`.name = '%s'", |
||
| 548 | $name |
||
| 549 | )); |
||
| 550 | |||
| 551 | if (!empty($delegates)) { |
||
| 552 | Symphony::Database()->delete('tbl_extensions_delegates', " `id` IN ('". implode("', '", $delegates). "') "); |
||
| 553 | } |
||
| 554 | |||
| 555 | // Remove the unused DB records |
||
| 556 | self::cleanupDatabase(); |
||
| 557 | |||
| 558 | return true; |
||
| 559 | } |
||
| 560 | |||
| 561 | /** |
||
| 562 | * This function checks that if the given extension has provided Fields, |
||
| 563 | * Data Sources or Events, that they aren't in use before the extension |
||
| 564 | * is uninstalled or disabled. This prevents exceptions from occurring when |
||
| 565 | * accessing an object that was using something provided by this Extension |
||
| 566 | * can't anymore because it has been removed. |
||
| 567 | * |
||
| 568 | * @param Extension $obj |
||
| 569 | * An extension object |
||
| 570 | * @throws SymphonyErrorPage |
||
| 571 | * @throws Exception |
||
| 572 | */ |
||
| 573 | private static function __canUninstallOrDisable(Extension $obj) |
||
| 574 | { |
||
| 575 | $extension_handle = strtolower(preg_replace('/^extension_/i', null, get_class($obj))); |
||
| 576 | $about = self::about($extension_handle); |
||
| 577 | |||
| 578 | // Fields: |
||
| 579 | if (is_dir(EXTENSIONS . "/{$extension_handle}/fields")) { |
||
| 580 | foreach (glob(EXTENSIONS . "/{$extension_handle}/fields/field.*.php") as $file) { |
||
| 581 | $type = preg_replace(array('/^field\./i', '/\.php$/i'), null, basename($file)); |
||
| 582 | |||
| 583 | if (FieldManager::isFieldUsed($type)) { |
||
| 584 | throw new Exception( |
||
| 585 | __('The field ‘%s’, provided by the Extension ‘%s’, is currently in use.', array(basename($file), $about['name'])) |
||
| 586 | . ' ' . __("Please remove it from your sections prior to uninstalling or disabling.") |
||
| 587 | ); |
||
| 588 | } |
||
| 589 | } |
||
| 590 | } |
||
| 591 | |||
| 592 | // Data Sources: |
||
| 593 | if (is_dir(EXTENSIONS . "/{$extension_handle}/data-sources")) { |
||
| 594 | foreach (glob(EXTENSIONS . "/{$extension_handle}/data-sources/data.*.php") as $file) { |
||
| 595 | $handle = preg_replace(array('/^data\./i', '/\.php$/i'), null, basename($file)); |
||
| 596 | |||
| 597 | if (PageManager::isDataSourceUsed($handle)) { |
||
| 598 | throw new Exception( |
||
| 599 | __('The Data Source ‘%s’, provided by the Extension ‘%s’, is currently in use.', array(basename($file), $about['name'])) |
||
| 600 | . ' ' . __("Please remove it from your pages prior to uninstalling or disabling.") |
||
| 601 | ); |
||
| 602 | } |
||
| 603 | } |
||
| 604 | } |
||
| 605 | |||
| 606 | // Events |
||
| 607 | if (is_dir(EXTENSIONS . "/{$extension_handle}/events")) { |
||
| 608 | foreach (glob(EXTENSIONS . "/{$extension_handle}/events/event.*.php") as $file) { |
||
| 609 | $handle = preg_replace(array('/^event\./i', '/\.php$/i'), null, basename($file)); |
||
| 610 | |||
| 611 | if (PageManager::isEventUsed($handle)) { |
||
| 612 | throw new Exception( |
||
| 613 | __('The Event ‘%s’, provided by the Extension ‘%s’, is currently in use.', array(basename($file), $about['name'])) |
||
| 614 | . ' ' . __("Please remove it from your pages prior to uninstalling or disabling.") |
||
| 615 | ); |
||
| 616 | } |
||
| 617 | } |
||
| 618 | } |
||
| 619 | |||
| 620 | // Text Formatters |
||
| 621 | if (is_dir(EXTENSIONS . "/{$extension_handle}/text-formatters")) { |
||
| 622 | foreach (glob(EXTENSIONS . "/{$extension_handle}/text-formatters/formatter.*.php") as $file) { |
||
| 623 | $handle = preg_replace(array('/^formatter\./i', '/\.php$/i'), null, basename($file)); |
||
| 624 | |||
| 625 | if (FieldManager::isTextFormatterUsed($handle)) { |
||
| 626 | throw new Exception( |
||
| 627 | __('The Text Formatter ‘%s’, provided by the Extension ‘%s’, is currently in use.', array(basename($file), $about['name'])) |
||
| 628 | . ' ' . __("Please remove it from your fields prior to uninstalling or disabling.") |
||
| 629 | ); |
||
| 630 | } |
||
| 631 | } |
||
| 632 | } |
||
| 633 | } |
||
| 634 | |||
| 635 | /** |
||
| 636 | * Given a delegate name, notify all extensions that have registered to that |
||
| 637 | * delegate to executing their callbacks with a `$context` array parameter |
||
| 638 | * that contains information about the current Symphony state. |
||
| 639 | * |
||
| 640 | * @param string $delegate |
||
| 641 | * The delegate name |
||
| 642 | * @param string $page |
||
| 643 | * The current page namespace that this delegate operates in |
||
| 644 | * @param array $context |
||
| 645 | * The `$context` param is an associative array that at minimum will contain |
||
| 646 | * the current Administration class, the current page object and the delegate |
||
| 647 | * name. Other context information may be passed to this function when it is |
||
| 648 | * called. eg. |
||
| 649 | * |
||
| 650 | * array( |
||
| 651 | * 'parent' =>& $this->Parent, |
||
| 652 | * 'page' => $page, |
||
| 653 | * 'delegate' => $delegate |
||
| 654 | * ); |
||
| 655 | * @throws Exception |
||
| 656 | * @throws SymphonyErrorPage |
||
| 657 | * @return null|void |
||
| 658 | */ |
||
| 659 | public static function notifyMembers($delegate, $page, array $context = array()) |
||
| 709 | } |
||
| 710 | } |
||
| 711 | } |
||
| 712 | |||
| 713 | /** |
||
| 714 | * Returns an array of all the enabled extensions available |
||
| 715 | * |
||
| 716 | * @return array |
||
| 717 | */ |
||
| 718 | public static function listInstalledHandles() |
||
| 719 | { |
||
| 720 | if (empty(self::$_enabled_extensions) && Symphony::Database()->isConnected()) { |
||
| 721 | self::$_enabled_extensions = Symphony::Database()->fetchCol( |
||
| 722 | 'name', |
||
| 723 | "SELECT `name` FROM `tbl_extensions` WHERE `status` = 'enabled'" |
||
| 724 | ); |
||
| 725 | } |
||
| 726 | return self::$_enabled_extensions; |
||
| 727 | } |
||
| 728 | |||
| 729 | /** |
||
| 730 | * Will return an associative array of all extensions and their about information |
||
| 731 | * |
||
| 732 | * @param string $filter |
||
| 733 | * Allows a regular expression to be passed to return only extensions whose |
||
| 734 | * folders match the filter. |
||
| 735 | * @throws SymphonyErrorPage |
||
| 736 | * @throws Exception |
||
| 737 | * @return array |
||
| 738 | * An associative array with the key being the extension folder and the value |
||
| 739 | * being the extension's about information |
||
| 740 | */ |
||
| 741 | public static function listAll($filter = '/^((?![-^?%:*|"<>]).)*$/') |
||
| 742 | { |
||
| 743 | $result = array(); |
||
| 744 | $extensions = General::listDirStructure(EXTENSIONS, $filter, false, EXTENSIONS); |
||
| 745 | |||
| 746 | if (is_array($extensions) && !empty($extensions)) { |
||
| 747 | foreach ($extensions as $extension) { |
||
| 748 | $e = trim($extension, '/'); |
||
| 749 | |||
| 750 | if ($about = self::about($e)) { |
||
| 751 | $result[$e] = $about; |
||
| 752 | } |
||
| 753 | } |
||
| 754 | } |
||
| 755 | |||
| 756 | return $result; |
||
| 757 | } |
||
| 758 | |||
| 759 | /** |
||
| 760 | * Custom user sorting function used inside `fetch` to recursively sort authors |
||
| 761 | * by their names. |
||
| 762 | * |
||
| 763 | * @param array $a |
||
| 764 | * @param array $b |
||
| 765 | * @param integer $i |
||
| 766 | * @return integer |
||
| 767 | */ |
||
| 768 | private static function sortByAuthor($a, $b, $i = 0) |
||
| 787 | } |
||
| 788 | } |
||
| 789 | |||
| 790 | /** |
||
| 791 | * This function will return an associative array of Extension information. The |
||
| 792 | * information returned is defined by the `$select` parameter, which will allow |
||
| 793 | * a developer to restrict what information is returned about the Extension. |
||
| 794 | * Optionally, `$where` (not implemented) and `$order_by` parameters allow a developer to |
||
| 795 | * further refine their query. |
||
| 796 | * |
||
| 797 | * @param array $select (optional) |
||
| 798 | * Accepts an array of keys to return from the listAll() method. If omitted, all keys |
||
| 799 | * will be returned. |
||
| 800 | * @param array $where (optional) |
||
| 801 | * Not implemented. |
||
| 802 | * @param string $order_by (optional) |
||
| 803 | * Allows a developer to return the extensions in a particular order. The syntax is the |
||
| 804 | * same as other `fetch` methods. If omitted this will return resources ordered by `name`. |
||
| 805 | * @throws Exception |
||
| 806 | * @throws SymphonyErrorPage |
||
| 807 | * @return array |
||
| 808 | * An associative array of Extension information, formatted in the same way as the |
||
| 809 | * listAll() method. |
||
| 810 | */ |
||
| 811 | public static function fetch(array $select = array(), array $where = array(), $order_by = null) |
||
| 867 | } |
||
| 868 | |||
| 869 | /** |
||
| 870 | * This function will load an extension's meta information given the extension |
||
| 871 | * `$name`. Since Symphony 2.3, this function will look for an `extension.meta.xml` |
||
| 872 | * file inside the extension's folder. If this is not found, it will initialise |
||
| 873 | * the extension and invoke the `about()` function. By default this extension will |
||
| 874 | * return an associative array display the basic meta data about the given extension. |
||
| 875 | * If the `$rawXML` parameter is passed true, and the extension has a `extension.meta.xml` |
||
| 876 | * file, this function will return `DOMDocument` of the file. |
||
| 877 | * |
||
| 878 | * @param string $name |
||
| 879 | * The name of the Extension Class minus the extension prefix. |
||
| 880 | * @param boolean $rawXML |
||
| 881 | * If passed as true, and is available, this function will return the |
||
| 882 | * DOMDocument of representation of the given extension's `extension.meta.xml` |
||
| 883 | * file. If the file is not available, the extension will return the normal |
||
| 884 | * `about()` results. By default this is false. |
||
| 885 | * @throws Exception |
||
| 886 | * @throws SymphonyErrorPage |
||
| 887 | * @return array |
||
| 888 | * An associative array describing this extension |
||
| 889 | */ |
||
| 890 | public static function about($name, $rawXML = false) |
||
| 1004 | } |
||
| 1005 | } |
||
| 1006 | |||
| 1007 | /** |
||
| 1008 | * Creates an instance of a given class and returns it |
||
| 1009 | * |
||
| 1010 | * @param string $name |
||
| 1011 | * The name of the Extension Class minus the extension prefix. |
||
| 1012 | * @throws Exception |
||
| 1013 | * @throws SymphonyErrorPage |
||
| 1014 | * @return Extension |
||
| 1015 | */ |
||
| 1016 | public static function create($name) |
||
| 1017 | { |
||
| 1018 | if (!isset(self::$_pool[$name])) { |
||
| 1019 | $classname = self::__getClassName($name); |
||
| 1020 | $path = self::__getDriverPath($name); |
||
| 1021 | |||
| 1022 | if (!is_file($path)) { |
||
| 1023 | $errMsg = __('Could not find extension %s at location %s.', array( |
||
| 1024 | '<code>' . $name . '</code>', |
||
| 1025 | '<code>' . str_replace(DOCROOT . '/', '', $path) . '</code>' |
||
| 1026 | )); |
||
| 1027 | try { |
||
| 1028 | Symphony::Engine()->throwCustomError( |
||
| 1029 | $errMsg, |
||
| 1030 | __('Symphony Extension Missing Error'), |
||
| 1031 | Page::HTTP_STATUS_ERROR, |
||
| 1032 | 'missing_extension', |
||
| 1033 | array( |
||
| 1034 | 'name' => $name, |
||
| 1035 | 'path' => $path |
||
| 1036 | ) |
||
| 1037 | ); |
||
| 1038 | } catch (Exception $ex) { |
||
| 1039 | throw new Exception($errMsg, 0, $ex); |
||
| 1040 | } |
||
| 1041 | } |
||
| 1042 | |||
| 1043 | if (!class_exists($classname)) { |
||
| 1044 | require_once($path); |
||
| 1045 | } |
||
| 1046 | |||
| 1047 | // Create the extension object |
||
| 1048 | self::$_pool[$name] = new $classname(array()); |
||
| 1049 | } |
||
| 1050 | |||
| 1051 | return self::$_pool[$name]; |
||
| 1052 | } |
||
| 1053 | |||
| 1054 | /** |
||
| 1055 | * A utility function that is used by the ExtensionManager to ensure |
||
| 1056 | * stray delegates are not in `tbl_extensions_delegates`. It is called when |
||
| 1057 | * a new Delegate is added or removed. |
||
| 1058 | */ |
||
| 1059 | public static function cleanupDatabase() |
||
| 1080 | } |
||
| 1081 | } |
||
| 1082 | } |
||
| 1083 | } |
||
| 1084 | } |
||
| 1085 |
Loading history...
