PHP Craft::app方法代码示例

 /**
  * Exports the Craft datamodel.
  *
  * @param string $file    file to write the schema to
  * @param array  $exclude Data to not export
  *
  * @return int
  */
 public function actionIndex($file = 'craft/config/schema.yml', array $exclude = null)
 {
     $dataTypes = Schematic::getExportableDataTypes();
     // If there are data exclusions.
     if ($exclude !== null) {
         // Find any invalid data to exclude.
         $invalidExcludes = array_diff($exclude, $dataTypes);
         // If any invalid exclusions were specified.
         if (count($invalidExcludes) > 0) {
             $errorMessage = 'Invalid exlude';
             if (count($invalidExcludes) > 1) {
                 $errorMessage .= 's';
             }
             $errorMessage .= ': ' . implode(', ', $invalidExcludes) . '.';
             $errorMessage .= ' Valid exclusions are ' . implode(', ', $dataTypes);
             // Output an error message outlining what invalid exclusions were specified.
             echo "\n" . $errorMessage . "\n\n";
             return 1;
         }
         // Remove any explicitly excluded data types from the list of data types to export.
         $dataTypes = array_diff($dataTypes, $exclude);
     }
     Craft::app()->schematic->exportToYaml($file, $dataTypes);
     Craft::log(Craft::t('Exported schema to {file}', ['file' => $file]));
     return 0;
 }

 /**
  * @return ConsoleApp|WebApp
  */
 protected function getCraft()
 {
     if (!$this->craft) {
         $this->craft = Craft::app();
     }
     return $this->craft;
 }

 /**
  * Import asset source definitions.
  *
  * @param array $assetSourceDefinitions
  * @param bool  $force
  *
  * @return Result
  */
 public function import(array $assetSourceDefinitions, $force = false)
 {
     Craft::log(Craft::t('Importing Asset Sources'));
     foreach ($assetSourceDefinitions as $assetHandle => $assetSourceDefinition) {
         $assetSource = $this->populateAssetSource($assetHandle, $assetSourceDefinition);
         if (!Craft::app()->assetSources->saveSource($assetSource)) {
             $this->addErrors($assetSource->getAllErrors());
         }
     }
     return $this->getResultModel();
 }

 /**
  * @param array                $fieldDefinition
  * @param FieldModel           $field
  * @param string               $fieldHandle
  * @param FieldGroupModel|null $group
  */
 public function populate(array $fieldDefinition, FieldModel $field, $fieldHandle, FieldGroupModel $group = null)
 {
     parent::populate($fieldDefinition, $field, $fieldHandle, $group);
     $settings = $fieldDefinition['settings'];
     $defaultUploadLocationSourceId = $settings['defaultUploadLocationSource'];
     $defaultUploadLocationSource = Craft::app()->schematic_assetSources->getSourceTypeByHandle($defaultUploadLocationSourceId);
     $settings['defaultUploadLocationSource'] = $defaultUploadLocationSource ? $defaultUploadLocationSource->id : '';
     $singleUploadLocationSourceId = $settings['singleUploadLocationSource'];
     $singleUploadLocationSource = Craft::app()->schematic_assetSources->getSourceTypeByHandle($singleUploadLocationSourceId);
     $settings['singleUploadLocationSource'] = $singleUploadLocationSource ? $singleUploadLocationSource->id : '';
     $field->settings = $settings;
 }

 /**
  * Imports the Craft datamodel.
  *
  * @param string $file          yml file containing the schema definition
  * @param string $override_file yml file containing the override values
  * @param bool   $force         if set to true items not in the import will be deleted
  *
  * @return int
  */
 public function actionIndex($file = 'craft/config/schema.yml', $override_file = 'craft/config/override.yml', $force = false)
 {
     if (!IOHelper::fileExists($file)) {
         $this->usageError(Craft::t('File not found.'));
     }
     $result = Craft::app()->schematic->importFromYaml($file, $override_file, $force);
     if (!$result->hasErrors()) {
         Craft::log(Craft::t('Loaded schema from {file}', ['file' => $file]));
         return 0;
     }
     Craft::log(Craft::t('There was an error loading schema from {file}', ['file' => $file]));
     print_r($result->getErrors());
     return 1;
 }

 /**
  * Attempt to import user settings.
  *
  * @param array $user_settings
  * @param bool  $force         If set to true user settings not included in the import will be deleted
  *
  * @return Result
  */
 public function import(array $user_settings, $force = true)
 {
     Craft::log(Craft::t('Importing Users'));
     // always delete existing fieldlayout first
     Craft::app()->fields->deleteLayoutsByType(ElementType::User);
     if (isset($user_settings['fieldLayout'])) {
         $fieldLayoutDefinition = (array) $user_settings['fieldLayout'];
     } else {
         $fieldLayoutDefinition = [];
     }
     $fieldLayout = Craft::app()->schematic_fields->getFieldLayout($fieldLayoutDefinition);
     $fieldLayout->type = ElementType::User;
     if (!Craft::app()->fields->saveLayout($fieldLayout)) {
         // Save fieldlayout via craft
         $this->addErrors($fieldLayout->getAllErrors());
     }
     return $this->getResultModel();
 }

 /**
  * Determines if Craft is installed by checking if the info table exists.
  *
  * @return bool
  */
 public function isInstalled()
 {
     if (!isset($this->_isInstalled)) {
         try {
             // First check to see if DbConnection has even been initialized, yet.
             if (Craft::app()->getComponent('db')) {
                 // If the db config isn't valid, then we'll assume it's not installed.
                 if (!Craft::app()->getIsDbConnectionValid()) {
                     return false;
                 }
             } else {
                 return false;
             }
         } catch (\Exception $e) {
             return false;
         }
         $this->_isInstalled = Craft::app()->db->tableExists('info', false);
     }
     return $this->_isInstalled;
 }

 /**
  * Test users service import.
  *
  * @covers ::import
  */
 public function testUsersServiceImportWithImportError()
 {
     $mockFieldsService = $this->getMockFieldServiceForImport(false);
     $mockSchematicFieldsService = $this->getMockSchematicFieldServiceForImport(true);
     $this->setComponent(Craft::app(), 'fields', $mockFieldsService);
     $this->setComponent(Craft::app(), 'schematic_fields', $mockSchematicFieldsService);
     $import = $this->schematicUsersService->import([]);
     $this->assertTrue($import instanceof Result);
     $this->assertTrue($import->hasErrors('errors'));
 }

 /**
  * Test export functionality.
  *
  * @covers ::export
  */
 public function testExport()
 {
     $data = $this->getLocaleData();
     $locales = [];
     foreach ($data as $id) {
         $locales[] = new LocaleModel($id);
     }
     $mockLocalizationService = $this->getMockLocalizationService($data, $locales);
     $this->setComponent(Craft::app(), 'i18n', $mockLocalizationService);
     $export = $this->schematicLocalesService->export();
     $this->assertEquals($data, $export);
 }

 /**
  * @return Mock|DbConnection
  */
 private function setMockDbConnection()
 {
     $mockDbConnection = $this->getMockBuilder(DbConnection::class)->disableOriginalConstructor()->setMethods(['createCommand'])->getMock();
     $mockDbConnection->autoConnect = false;
     // Do not auto connect
     $mockDbCommand = $this->getMockDbCommand();
     $mockDbConnection->expects($this->any())->method('createCommand')->willReturn($mockDbCommand);
     Craft::app()->setComponent('db', $mockDbConnection);
     return $mockDbConnection;
 }

 /**
  * @param AssetSourceModel $assetSource
  *
  * @return array
  */
 private function getAssetSourceDefinition(AssetSourceModel $assetSource)
 {
     return ['type' => $assetSource->type, 'name' => $assetSource->name, 'sortOrder' => $assetSource->sortOrder, 'settings' => $assetSource->settings, 'fieldLayout' => Craft::app()->schematic_fields->getFieldLayoutDefinition($assetSource->getFieldLayout())];
 }

 /**
  * @param string $handle
  * @param Mock   $mock
  */
 private function setCraftComponent($handle, Mock $mock)
 {
     $this->setComponent(Craft::app(), $handle, $mock);
 }

 /**
  * @param array $schematicFieldModels
  */
 private function setMockPluginsService(array $schematicFieldModels)
 {
     $mockPluginsService = $this->getMockBuilder(PluginsService::class)->disableOriginalConstructor()->getMock();
     $mockPluginsService->expects($this->exactly(1))->method('call')->with('registerSchematicFieldModels')->willReturn($schematicFieldModels);
     $this->setComponent(Craft::app(), 'plugins', $mockPluginsService);
 }

 /**
  * Populate globalset.
  *
  * @param GlobalSetModel $globalSet
  * @param array          $globalSetDefinition
  * @param string         $globalSetHandle
  */
 private function populateGlobalSet(GlobalSetModel $globalSet, array $globalSetDefinition, $globalSetHandle)
 {
     $globalSet->setAttributes(['handle' => $globalSetHandle, 'name' => $globalSetDefinition['name']]);
     $fieldLayout = Craft::app()->schematic_fields->getFieldLayout($globalSetDefinition['fieldLayout']);
     $globalSet->setFieldLayout($fieldLayout);
 }

 /**
  * Get a prepared fieldLayout for the craft assembleLayout function.
  *
  * @param array $fieldLayoutDef
  *
  * @return array
  */
 private function getPrepareFieldLayout(array $fieldLayoutDef)
 {
     $layoutFields = [];
     $requiredFields = [];
     foreach ($fieldLayoutDef as $fieldHandle => $required) {
         $field = Craft::app()->fields->getFieldByHandle($fieldHandle);
         if ($field instanceof FieldModel) {
             $layoutFields[] = $field->id;
             if ($required) {
                 $requiredFields[] = $field->id;
             }
         }
     }
     return ['fields' => $layoutFields, 'required' => $requiredFields];
 }