PHP common_ext_ExtensionsManager类代码示例

 /**
  * 
  * @param string $currentVersion
  * @return string $versionUpdatedTo
  */
 public function update($initialVersion)
 {
     $currentVersion = $initialVersion;
     //migrate from 2.6 to 2.6.1
     if ($currentVersion == '2.6') {
         //data upgrade
         OntologyUpdater::syncModels();
         $currentVersion = '2.6.1';
     }
     if ($currentVersion == '2.6.1') {
         $ext = \common_ext_ExtensionsManager::singleton()->getExtensionById('taoDelivery');
         $className = $ext->getConfig(\taoDelivery_models_classes_execution_ServiceProxy::CONFIG_KEY);
         if (is_string($className)) {
             $impl = null;
             switch ($className) {
                 case 'taoDelivery_models_classes_execution_OntologyService':
                     $impl = new \taoDelivery_models_classes_execution_OntologyService();
                     break;
                 case 'taoDelivery_models_classes_execution_KeyValueService':
                     $impl = new \taoDelivery_models_classes_execution_KeyValueService(array(\taoDelivery_models_classes_execution_KeyValueService::OPTION_PERSISTENCE => 'deliveryExecution'));
                     break;
                 default:
                     \common_Logger::w('Unable to migrate custom execution service');
             }
             if (!is_null($impl)) {
                 $proxy = \taoDelivery_models_classes_execution_ServiceProxy::singleton();
                 $proxy->setImplementation($impl);
                 $currentVersion = '2.6.2';
             }
         }
     }
     return $currentVersion;
 }

 /**
  * get the lang of the class in case we want to filter the media on language
  *
  * @param array $options
  */
 public function __construct($options = array())
 {
     parent::__construct($options);
     \common_ext_ExtensionsManager::singleton()->getExtensionById('taoMediaManager');
     $this->lang = isset($options['lang']) ? $options['lang'] : '';
     $this->rootClassUri = isset($options['rootClass']) ? $options['rootClass'] : MediaService::singleton()->getRootClass();
 }

 /**
  * @param $params
  * @return Report
  */
 public function __invoke($params)
 {
     \common_ext_ExtensionsManager::singleton()->getExtensionById('taoProctoring');
     \common_ext_ExtensionsManager::singleton()->getExtensionById('taoDeliveryRdf');
     \common_ext_ExtensionsManager::singleton()->getExtensionById('taoQtiTest');
     $report = new Report(Report::TYPE_INFO, 'Updating of delivery monitoring cache...');
     $testCenters = TestCenterService::singleton()->getRootClass()->getInstances(true);
     $deliveryMonitoringService = $this->getServiceLocator()->get(DeliveryMonitoringService::CONFIG_ID);
     $deliveryService = $this->getServiceLocator()->get(DeliveryService::CONFIG_ID);
     $eligibilityService = EligibilityService::singleton();
     foreach ($testCenters as $testCenter) {
         $deliveries = $eligibilityService->getEligibleDeliveries($testCenter, false);
         foreach ($deliveries as $delivery) {
             if ($delivery->exists()) {
                 $deliveryExecutions = $deliveryService->getCurrentDeliveryExecutions($delivery->getUri(), $testCenter->getUri());
                 foreach ($deliveryExecutions as $deliveryExecution) {
                     $data = $deliveryMonitoringService->getData($deliveryExecution, true);
                     if ($deliveryMonitoringService->save($data)) {
                         $report->add(new Report(Report::TYPE_SUCCESS, "Delivery execution {$deliveryExecution->getUri()} successfully updated."));
                     } else {
                         $errors = $data->getErrors();
                         $errorsStr = "    " . PHP_EOL;
                         array_walk($errors, function ($val, $key) use(&$errorsStr) {
                             $errorsStr .= "    {$key} - {$val}" . PHP_EOL;
                         });
                         $report->add(new Report(Report::TYPE_ERROR, "Delivery execution {$deliveryExecution->getUri()} was not updated. {$errorsStr}"));
                     }
                 }
             }
         }
     }
     return $report;
 }

 public function __construct($extName)
 {
     $configFile = dirname(dirname(__DIR__)) . DIRECTORY_SEPARATOR . 'config' . DIRECTORY_SEPARATOR . 'generis.conf.php';
     parent::__construct($configFile);
     // load extension constants
     common_ext_ExtensionsManager::singleton()->getExtensionById($extName);
 }

 public function run()
 {
     // load the constants
     common_ext_ExtensionsManager::singleton()->getExtensionById('taoDelivery');
     $this->migrateCompiledDeliveryToAssembly();
     $this->removeAssemblyFromGroup();
 }

 public function scriptRunner($script, $extension)
 {
     $error = false;
     $errorStack = array();
     if (isset($extension) && $extension != null) {
         $ext = common_ext_ExtensionsManager::singleton()->getExtensionById($extension);
     }
     if ($script != null) {
         $parameters = array();
         $options = array('argv' => array(0 => 'Script ' . $script), 'output_mode' => 'log_only');
         try {
             $scriptName = $script;
             if (!class_exists($scriptName)) {
                 throw new taoUpdate_models_classes_UpdateException('Could not find scriptName class ' . $script);
             }
             new $scriptName(array('parameters' => $parameters), $options);
             $error = false;
         } catch (Exception $e) {
             common_Logger::e('Error occurs during update ' . $e->getMessage());
             $error = true;
             $errorStack[] = 'Error in script ' . $script . ' ' . $e->getMessage();
         }
         if ($error) {
             echo json_encode(array('success' => 0, 'failed' => $errorStack));
         } else {
             echo json_encode(array('success' => 1, 'failed' => array()));
         }
     } else {
         echo json_encode(array('success' => 0, 'failed' => array('not scriptname provided')));
     }
 }

 public function run()
 {
     $extmanger = common_ext_ExtensionsManager::singleton();
     $ext = $extmanger->getExtensionById('taoCe');
     $extinstaller = new tao_install_ExtensionInstaller($ext);
     $extinstaller->install();
 }

 public function __invoke($params)
 {
     // recreate languages
     $modelCreator = new \tao_install_utils_ModelCreator(LOCAL_NAMESPACE);
     $models = $modelCreator->getLanguageModels();
     foreach ($models as $ns => $modelFiles) {
         foreach ($modelFiles as $file) {
             $modelCreator->insertLocalModel($file);
         }
     }
     OntologyUpdater::syncModels();
     // reapply access rights
     $exts = \common_ext_ExtensionsManager::singleton()->getInstalledExtensions();
     foreach ($exts as $ext) {
         $installer = new \tao_install_ExtensionInstaller($ext);
         $installer->installManagementRole();
         $installer->applyAccessRules();
     }
     // recreate admin
     if (count($params) >= 2) {
         $login = array_shift($params);
         $password = array_shift($params);
         $sysAdmin = $this->getResource(INSTANCE_ROLE_SYSADMIN);
         $userClass = $this->getClass(CLASS_TAO_USER);
         \core_kernel_users_Service::singleton()->addUser($login, $password, $sysAdmin, $userClass);
     }
     // empty cache
     \common_cache_FileCache::singleton()->purge();
     return \common_report_Report::createSuccess('All done');
 }

 /**
  * call the (empty) parent constructor
  * initialise the campaign class
  *
  * @access protected
  * @author Joel Bout, <joel@taotesting.com>
  * @return mixed
  */
 protected function __construct()
 {
     parent::__construct();
     // ensure the taoCampaign extension is loaded, since it can be called from taoDelivery
     common_ext_ExtensionsManager::singleton()->getExtensionById('taoCampaign')->load();
     $this->campaignClass = new core_kernel_classes_Class(TAO_DELIVERY_CAMPAIGN_CLASS);
 }

 public static function getFinishedSniplet()
 {
     $taoExt = common_ext_ExtensionsManager::singleton()->getExtensionById('tao');
     $tpl = $taoExt->getConstant('DIR_VIEWS') . 'templates' . DIRECTORY_SEPARATOR . 'snippet' . DIRECTORY_SEPARATOR . 'finishService.tpl';
     $renderer = new Renderer($tpl);
     return $renderer->render();
 }

 public function testImport()
 {
     \common_ext_ExtensionsManager::singleton()->getExtensionById('taoItems');
     $url = $this->host . 'taoQtiItem/RestQtiItem/import';
     $post_data = ['content' => new \CURLFile(__DIR__ . '/../samples/package/QTI/package.zip', 'application/zip')];
     $return = $this->curl($url, CURLOPT_POST, 'data', array(CURLOPT_POSTFIELDS => $post_data));
     $data = json_decode($return, true);
     $this->assertInternalType('array', $data);
     $this->assertTrue(isset($data['success']));
     $this->assertTrue($data['success']);
     $this->assertTrue(isset($data['data']['items']));
     $items = $data['data']['items'];
     $this->assertInternalType('array', $items);
     $this->assertEquals(1, count($items));
     $itemUri = reset($items);
     $this->assertInternalType('string', $itemUri);
     $item = $this->getResource($itemUri);
     $this->assertTrue($item->exists());
     $itemService = \taoItems_models_classes_ItemsService::singleton();
     $model = $itemService->getItemModel($item);
     $this->assertNotNull($model);
     $this->assertEquals(ItemModel::MODEL_URI, $itemService->getItemModel($item)->getUri());
     $this->assertTrue($itemService->deleteResource($item));
     $this->assertFalse($item->exists());
 }

 /**
  * @param array $params
  * @return Report
  */
 public function __invoke($params)
 {
     $this->params = $params;
     $this->report = new Report(Report::TYPE_INFO, 'Termination expired paused executions...');
     common_Logger::d('Termination expired paused execution started at ' . date(DATE_RFC3339));
     \common_ext_ExtensionsManager::singleton()->getExtensionById('taoDeliveryRdf');
     \common_ext_ExtensionsManager::singleton()->getExtensionById('taoQtiTest');
     $deliveryExecutionService = \taoDelivery_models_classes_execution_ServiceProxy::singleton();
     $count = 0;
     $testSessionService = ServiceManager::getServiceManager()->get(TestSessionService::SERVICE_ID);
     /** @var DeliveryMonitoringService $deliveryMonitoringService */
     $deliveryMonitoringService = ServiceManager::getServiceManager()->get(DeliveryMonitoringService::CONFIG_ID);
     $deliveryExecutionsData = $deliveryMonitoringService->find([DeliveryMonitoringService::STATUS => [DeliveryExecution::STATE_ACTIVE, DeliveryExecution::STATE_PAUSED]]);
     foreach ($deliveryExecutionsData as $deliveryExecutionData) {
         $data = $deliveryExecutionData->get();
         $deliveryExecution = $deliveryExecutionService->getDeliveryExecution($data[DeliveryMonitoringService::DELIVERY_EXECUTION_ID]);
         if ($testSessionService->isExpired($deliveryExecution)) {
             try {
                 $this->terminateExecution($deliveryExecution);
                 $count++;
             } catch (\Exception $e) {
                 $this->addReport(Report::TYPE_ERROR, $e->getMessage());
             }
         }
     }
     $msg = $count > 0 ? "{$count} executions has been terminated." : "Expired executions not found.";
     $this->addReport(Report::TYPE_INFO, $msg);
     common_Logger::d('Termination expired paused execution finished at ' . date(DATE_RFC3339));
     return $this->report;
 }

 /**
  * Constructor performs initializations actions
  * @return void
  */
 public function __construct()
 {
     parent::__construct();
     $this->userService = tao_models_classes_UserService::singleton();
     $this->defaultData();
     $extManager = common_ext_ExtensionsManager::singleton();
 }

 public function run()
 {
     $this->out('Bypassing model restriction');
     $oldUpdatableModels = core_kernel_persistence_smoothsql_SmoothModel::getUpdatableModelIds();
     core_kernel_persistence_smoothsql_SmoothModel::forceUpdatableModelIds(core_kernel_persistence_smoothsql_SmoothModel::getReadableModelIds());
     $this->out('Loading extensions');
     $diffPath = dirname(__FILE__) . DIRECTORY_SEPARATOR . 'ontologyData26' . DIRECTORY_SEPARATOR;
     // remove All
     foreach (common_ext_ExtensionsManager::singleton()->getInstalledExtensions() as $extension) {
         $diffFile = $diffPath . 'diff' . ucfirst($extension->getId()) . '.php';
         if (file_exists($diffFile)) {
             $this->out('Updating model of ' . $extension->getId());
             $data = (include $diffFile);
             foreach ($data['toRemove'] as $tripple) {
                 $this->remove($tripple);
             }
         }
     }
     // add All
     foreach (common_ext_ExtensionsManager::singleton()->getInstalledExtensions() as $extension) {
         $diffFile = $diffPath . 'diff' . ucfirst($extension->getId()) . '.php';
         if (file_exists($diffFile)) {
             $this->out('Updating model of ' . $extension->getId());
             $data = (include $diffFile);
             foreach ($data['toAdd'] as $tripple) {
                 $this->add($tripple);
             }
         }
     }
     $this->out('Restoring model restriction');
     core_kernel_persistence_smoothsql_SmoothModel::forceUpdatableModelIds($oldUpdatableModels);
 }

 /**
  * @param string $initialVersion
  * @return string string
  */
 public function update($initialVersion)
 {
     $currentVersion = $initialVersion;
     $ext = \common_ext_ExtensionsManager::singleton()->getExtensionById('ltiTestConsumer');
     $this->setVersion($currentVersion);
     $this->skip('0.8', '0.9.0');
 }