@param string|array $importProperties

@return LayoutUpdateImport
324356
private function createImport($importProperties)
    {
        if (!is_array($importProperties)) {
            $importProperties = [ImportsAwareLayoutUpdateInterface::ID_KEY => $importProperties];
        }

        return LayoutUpdateImport::createFromArray($importProperties);
    }
291481
protected function getRootId(LayoutUpdateImport $import)
    {
        $rootId = $import->getRoot();
        if ($import->getParent()) {
            if ($rootId === self::ROOT_PLACEHOLDER) {
                $rootId = $this->getRootId($import->getParent());
            } else {
                $this->replaceNamespace($rootId, $this->getNamespace($import->getParent()));
            }
        }
        return $rootId;
    }
3607
public function createPropertyPathsFromCommentArray($comments)
    {
        $out = '';

        foreach ($comments as $mainKey => $subKeys) {
            foreach ($subKeys as $subKey => $comment) {
                // uncommented entries are undocumented & for internal use only (I guess)
                if ('' === $comment) {
                    continue;
                }

                $defaultConfigurationValue = $this->defaultConfiguration[$mainKey][$subKey];

                // non-scalar values are not available in InstallTool (& also not handled by phing properties)
                if (FALSE === is_scalar($defaultConfigurationValue)) {
                    continue;
                }

                $out .= strtr($this->outputLine, array(
                    '%newline%' => chr(10),
                    '%comment%' => $comment,
                    '%mainKey%' => $mainKey,
                    '%subKey%' => $subKey,
                    '%defaultConfigurationValue%' => $defaultConfigurationValue,
                ));
            }
        }

        return $out;
    }
950405
public function import(?DataImporterConfigurationTransfer $dataImporterConfigurationTransfer = null): DataImporterReportTransfer
    {
        return $this->getFactory()->createCompanyUnitAddressLabelDataImport()->import($dataImporterConfigurationTransfer);
    }
617464
public function import(Tenant $tenant, ImportRecordsDataTable $importRecordsDataTable)
    {
        return $importRecordsDataTable->with([
            'resource' => $tenant,
            'tabs' => 'adminarea.tenants.tabs',
            'url' => route('adminarea.tenants.stash'),
            'id' => "adminarea-tenants-{$tenant->getRouteKey()}-import-table",
        ])->render('cortex/foundation::adminarea.pages.datatable-dropzone');
    }
1260134
protected function buildContextInstance(array $contextProperties)
    {
        $contextProperties = $this->removeDeprecatedProperties($contextProperties);

        return new ContentContext(
            $contextProperties['workspaceName'],
            $contextProperties['currentDateTime'],
            $contextProperties['dimensions'],
            $contextProperties['targetDimensions'],
            $contextProperties['invisibleContentShown'],
            $contextProperties['removedContentShown'],
            $contextProperties['inaccessibleContentShown'],
            $contextProperties['currentSite'],
            $contextProperties['currentDomain']
        );
    }
1207745
public void addImport(String imprt, int lineNo) {
        imports.add(imprt);
        if (imprt.endsWith(".*")) {
            imprt = imprt.substring(0, imprt.lastIndexOf(".*"));
            templateClass.importPaths.add(imprt);
        }
        importLineMap.put(imprt, lineNo);
    }
1260408
public function importCompanyRoles(?DataImporterConfigurationTransfer $dataImporterConfigurationTransfer = null): DataImporterReportTransfer
    {
        return $this->getFactory()->createCompanyRoleDataImport()->import($dataImporterConfigurationTransfer);
    }
453449
public void addExportedPackages(String... exportedPackages) {
		String oldBundles = mainAttributes.get(EXPORT_PACKAGE);
		if (oldBundles == null)
			oldBundles = "";
		BundleList oldResultList = BundleList.fromInput(oldBundles, newline);
		BundleList resultList = BundleList.fromInput(oldBundles, newline);
		for (String bundle : exportedPackages)
			resultList.mergeInto(Bundle.fromInput(bundle));
		String result = resultList.toString();
		boolean changed = !oldResultList.toString().equals(result);
		modified |= changed;
		if (changed)
			mainAttributes.put(EXPORT_PACKAGE, result);
	}
580971
public function importTenancyFrom(TenantContract $tenant)
    {
        $this->setTenantOwnerId($tenant->getTenantOwnerId());
        $this->setTenantCreatorId($tenant->getTenantCreatorId());

        return $this;
    }
425030
protected function getAdditionalBlockPrefixes($id, LayoutUpdateImport $import, $prefixes = [])
    {
        $prefixes[] = sprintf(self::ADDITIONAL_BLOCK_PREFIX_PATTERN, $import->getId(), $id);
        if ($import->getParent()) {
            $prefixes = $this->getAdditionalBlockPrefixes($id, $import->getParent(), $prefixes);
        }
        return $prefixes;
    }
268998
private function domImport()
    {
        $dom_import = @$this->dom->loadHTML($this->html_content);

        if(!!$dom_import)
        {
            $this->xpath = new \DOMXPath($this->dom);
        }
        else
        {
            $this->logger->logError('E002', array($this->html_content));
        }

        return $dom_import;
    }
1156646
protected function _importSuccess(ImportResult $importResult, EntityInterface $entity) : bool
    {
        $table = TableRegistry::get('CsvMigrations.ImportResults');
        Assert::isInstanceOf($table, ImportResultsTable::class);

        $importResult->set('model_id', $entity->get('id'));
        $importResult->set('status', $table::STATUS_SUCCESS);
        $importResult->set('status_message', $table::STATUS_SUCCESS_MESSAGE);

        return (bool)$table->save($importResult);
    }
78202
private function importSingleBundleTranslationFiles(ImportCommand $importCommand)
    {
        $this->validateBundleName($importCommand->getDefaultBundle());
        $bundles = array_change_key_case($this->kernel->getBundles(), CASE_LOWER);
        $finder = $this->translationFileExplorer->find($bundles[strtolower($importCommand->getDefaultBundle())]->getPath(), $this->determineLocalesToImport($importCommand));

        if ($finder === null) {
            return 0;
        }

        return $this->importTranslationFiles($finder, $importCommand->getForce());
    }
1059565
public function executeImportCommand(ImportCommand $importCommand)
    {
        if ($importCommand->getGlobals() || $importCommand->getDefaultBundle() === false || $importCommand->getDefaultBundle() === null) {
            return $this->importGlobalTranslationFiles($importCommand);
        }

        return $this->importBundleTranslationFiles($importCommand);
    }
1271551
public function importCompanyRolePermissions(?DataImporterConfigurationTransfer $dataImporterConfigurationTransfer = null): DataImporterReportTransfer
    {
        return $this->getFactory()->createCompanyRolePermissionDataImport()->import($dataImporterConfigurationTransfer);
    }
952928
public void addImportedPackages(String[] imports) {
        if (imports == null) { return; }

        for (String imported : imports) {
            this.mImports.add(imported);
        }
    }