Example usage for com.liferay.portal.kernel.xml Element attributeValue

List of usage examples for com.liferay.portal.kernel.xml Element attributeValue

  1. HOME
  2. Java
  3. com.liferay.portal
  4. com.liferay.portal.kernel.xml.*
  5. Element
  6. attributeValue

Introduction

In this page you can find the example usage for com.liferay.portal.kernel.xml Element attributeValue.

Prototype

public String attributeValue(String name);

Source Link

Usage

From source file:com.liferay.content.targeting.lar.UserSegmentStagedModelDataHandler.java

License:Open Source License

protected AssetCategory importAssetCategory(PortletDataContext portletDataContext, Element userSegmentElement)
        throws Exception {

    Element assetCategoryElement = userSegmentElement.element("category");

    String path = assetCategoryElement.attributeValue("path");

    AssetCategory assetCategory = (AssetCategory) portletDataContext.getZipEntryAsObject(path);

    AssetVocabulary assetVocabulary = importAssetVocabulary(portletDataContext, userSegmentElement);

    long userId = portletDataContext.getUserId(assetCategory.getUserUuid());

    ServiceContext serviceContext = portletDataContext.createServiceContext(assetCategory);

    serviceContext.setUserId(userId);//from   w ww .  java2  s  . co  m

    AssetCategory importedAssetCategory = null;

    if (portletDataContext.isDataStrategyMirror()) {
        AssetCategory existingAssetCategory = AssetCategoryLocalServiceUtil.fetchAssetCategoryByUuidAndGroupId(
                assetCategory.getUuid(), portletDataContext.getScopeGroupId());

        if (existingAssetCategory == null) {
            serviceContext.setUuid(assetCategory.getUuid());

            importedAssetCategory = AssetCategoryLocalServiceUtil.addCategory(userId,
                    AssetCategoryConstants.DEFAULT_PARENT_CATEGORY_ID, assetCategory.getTitleMap(),
                    assetCategory.getDescriptionMap(), assetVocabulary.getVocabularyId(), null, serviceContext);
        } else {
            importedAssetCategory = AssetCategoryLocalServiceUtil.updateCategory(userId,
                    existingAssetCategory.getCategoryId(), existingAssetCategory.getParentCategoryId(),
                    assetCategory.getTitleMap(), assetCategory.getDescriptionMap(),
                    existingAssetCategory.getVocabularyId(), null, serviceContext);
        }
    } else {
        importedAssetCategory = AssetCategoryLocalServiceUtil.addCategory(userId,
                AssetCategoryConstants.DEFAULT_PARENT_CATEGORY_ID, assetCategory.getTitleMap(),
                assetCategory.getDescriptionMap(), assetVocabulary.getVocabularyId(), null, serviceContext);
    }

    portletDataContext.importClassedModel(assetCategory, importedAssetCategory);

    return importedAssetCategory;
}

From source file:com.liferay.content.targeting.lar.UserSegmentStagedModelDataHandler.java

License:Open Source License

protected AssetVocabulary importAssetVocabulary(PortletDataContext portletDataContext,
        Element userSegmentElement) throws Exception {

    Element assetVocabularyElement = userSegmentElement.element("vocabulary");

    String path = assetVocabularyElement.attributeValue("path");

    AssetVocabulary assetVocabulary = (AssetVocabulary) portletDataContext.getZipEntryAsObject(path);

    long userId = portletDataContext.getUserId(assetVocabulary.getUserUuid());

    ServiceContext serviceContext = portletDataContext.createServiceContext(assetVocabulary);

    serviceContext.setUserId(userId);//from   w w w.  ja  va2s  . co m

    AssetVocabulary importedAssetVocabulary = null;

    if (portletDataContext.isDataStrategyMirror()) {
        AssetVocabulary existingAssetVocabulary = AssetVocabularyLocalServiceUtil
                .fetchAssetVocabularyByUuidAndGroupId(assetVocabulary.getUuid(),
                        portletDataContext.getScopeGroupId());

        if (existingAssetVocabulary == null) {
            serviceContext.setUuid(assetVocabulary.getUuid());

            importedAssetVocabulary = UserSegmentUtil.addAssetVocabulary(userId, serviceContext);
        } else {
            importedAssetVocabulary = existingAssetVocabulary;
        }
    } else {
        importedAssetVocabulary = UserSegmentUtil.addAssetVocabulary(userId, serviceContext);
    }

    portletDataContext.importClassedModel(assetVocabulary, importedAssetVocabulary);

    return importedAssetVocabulary;
}

From source file:com.liferay.content.targeting.lar.UserSegmentStagedModelDataHandler.java

License:Open Source License

protected void importRuleInstances(PortletDataContext portletDataContext, UserSegment userSegment,
        UserSegment importedUserSegment) throws Exception {

    List<Element> ruleInstanceElements = portletDataContext.getReferenceDataElements(userSegment,
            RuleInstance.class);

    for (Element ruleInstanceElement : ruleInstanceElements) {
        String ruleInstancePath = ruleInstanceElement.attributeValue("path");

        RuleInstance ruleInstance = (RuleInstance) portletDataContext.getZipEntryAsObject(ruleInstancePath);

        ruleInstance.setUserSegmentId(importedUserSegment.getUserSegmentId());

        StagedModelDataHandlerUtil.importStagedModel(portletDataContext, ruleInstance);
    }/*  ww  w.  j  a va2 s . c om*/
}

From source file:com.liferay.content.targeting.service.test.lar.BaseStagedModelDataHandlerTestCase.java

License:Open Source License

protected void validateExport(PortletDataContext portletDataContext, StagedModel stagedModel,
        Map<String, List<StagedModel>> dependentStagedModelsMap) throws Exception {

    Element rootElement = portletDataContext.getExportDataRootElement();

    List<Element> stagedModelGroupElements = rootElement.elements();

    for (Element stagedModelGroupElement : stagedModelGroupElements) {
        String className = stagedModelGroupElement.getName();

        List<StagedModel> dependentStagedModels = dependentStagedModelsMap.get(className);

        if (dependentStagedModels == null) {
            dependentStagedModels = new ArrayList<StagedModel>();
        } else {/*from  www  .  j  a  va2s .com*/
            dependentStagedModels = ListUtil.copy(dependentStagedModels);
        }

        Class<?> stagedModelClass = getStagedModelClass();

        if (className.equals(stagedModelClass.getSimpleName())) {
            dependentStagedModels.add(stagedModel);
        }

        List<Element> elements = stagedModelGroupElement.elements();

        Assert.assertEquals(dependentStagedModels.size(), elements.size());

        for (Element element : elements) {
            String path = element.attributeValue("path");

            Assert.assertNotNull(path);

            Iterator<StagedModel> iterator = dependentStagedModels.iterator();

            while (iterator.hasNext()) {
                StagedModel dependentStagedModel = iterator.next();

                String dependentStagedModelPath = ExportImportPathUtil.getModelPath(dependentStagedModel);

                if (path.equals(dependentStagedModelPath)) {
                    iterator.remove();
                }
            }
        }

        Assert.assertTrue("There is more than one element exported with the same path",
                dependentStagedModels.isEmpty());
    }
}

From source file:com.liferay.customsql.CustomSQL.java

License:Open Source License

protected void read(ClassLoader classLoader, String source) throws Exception {

    InputStream is = classLoader.getResourceAsStream(source);

    if (is == null) {
        return;//from   w  w w.  j a v a  2 s .  com
    }

    if (_log.isDebugEnabled()) {
        _log.debug("Loading " + source);
    }

    Document document = SAXReaderUtil.read(is);

    Element rootElement = document.getRootElement();

    for (Element sqlElement : rootElement.elements("sql")) {
        String file = sqlElement.attributeValue("file");

        if (Validator.isNotNull(file)) {
            read(classLoader, file);
        } else {
            String id = sqlElement.attributeValue("id");
            String content = transform(sqlElement.getText());

            content = replaceIsNull(content);

            _sqlPool.put(id, content);
        }
    }
}

From source file:com.liferay.document.library.internal.exportimport.data.handler.DLFileEntryTypeStagedModelDataHandler.java

License:Open Source License

@Override
public boolean validateReference(PortletDataContext portletDataContext, Element referenceElement) {

    validateMissingGroupReference(portletDataContext, referenceElement);

    String uuid = referenceElement.attributeValue("uuid");

    Map<Long, Long> groupIds = (Map<Long, Long>) portletDataContext.getNewPrimaryKeysMap(Group.class);

    long groupId = GetterUtil.getLong(referenceElement.attributeValue("group-id"));

    groupId = MapUtil.getLong(groupIds, groupId);

    String fileEntryTypeKey = referenceElement.attributeValue("file-entry-type-key");
    boolean preloaded = GetterUtil.getBoolean(referenceElement.attributeValue("preloaded"));

    DLFileEntryType existingFileEntryType = fetchExistingFileEntryType(uuid, groupId, fileEntryTypeKey,
            preloaded);// w  w w. jav  a  2s . c  o m

    if (existingFileEntryType == null) {
        return false;
    }

    return true;
}

From source file:com.liferay.document.library.internal.exportimport.data.handler.DLFileEntryTypeStagedModelDataHandler.java

License:Open Source License

@Override
protected void doImportMissingReference(PortletDataContext portletDataContext, Element referenceElement)
        throws PortletDataException {

    importMissingGroupReference(portletDataContext, referenceElement);

    String uuid = referenceElement.attributeValue("uuid");

    Map<Long, Long> groupIds = (Map<Long, Long>) portletDataContext.getNewPrimaryKeysMap(Group.class);

    long groupId = GetterUtil.getLong(referenceElement.attributeValue("group-id"));

    groupId = MapUtil.getLong(groupIds, groupId);

    String fileEntryTypeKey = referenceElement.attributeValue("file-entry-type-key");
    boolean preloaded = GetterUtil.getBoolean(referenceElement.attributeValue("preloaded"));

    DLFileEntryType existingFileEntryType = null;

    existingFileEntryType = fetchExistingFileEntryType(uuid, groupId, fileEntryTypeKey, preloaded);

    Map<Long, Long> fileEntryTypeIds = (Map<Long, Long>) portletDataContext
            .getNewPrimaryKeysMap(DLFileEntryType.class);

    long fileEntryTypeId = GetterUtil.getLong(referenceElement.attributeValue("class-pk"));

    fileEntryTypeIds.put(fileEntryTypeId, existingFileEntryType.getFileEntryTypeId());
}

From source file:com.liferay.document.library.internal.exportimport.data.handler.DLFileEntryTypeStagedModelDataHandler.java

License:Open Source License

@Override
protected void doImportStagedModel(PortletDataContext portletDataContext, DLFileEntryType fileEntryType)
        throws Exception {

    long userId = portletDataContext.getUserId(fileEntryType.getUserUuid());

    List<Element> ddmStructureReferenceElements = portletDataContext.getReferenceElements(fileEntryType,
            com.liferay.dynamic.data.mapping.model.DDMStructure.class);

    long[] ddmStructureIdsArray = new long[ddmStructureReferenceElements.size()];

    Map<Long, Long> ddmStructureIds = (Map<Long, Long>) portletDataContext
            .getNewPrimaryKeysMap(com.liferay.dynamic.data.mapping.model.DDMStructure.class);

    for (int i = 0; i < ddmStructureReferenceElements.size(); i++) {
        Element ddmStructureReferenceElement = ddmStructureReferenceElements.get(i);

        long ddmStructureId = GetterUtil.getLong(ddmStructureReferenceElement.attributeValue("class-pk"));

        ddmStructureIdsArray[i] = MapUtil.getLong(ddmStructureIds, ddmStructureId);
    }/*from  ww w .j a va 2  s.c  om*/

    ServiceContext serviceContext = portletDataContext.createServiceContext(fileEntryType);

    DLFileEntryType importedDLFileEntryType = null;

    Element element = portletDataContext.getImportDataStagedModelElement(fileEntryType);

    boolean preloaded = GetterUtil.getBoolean(element.attributeValue("preloaded"));

    if (portletDataContext.isDataStrategyMirror()) {
        DLFileEntryType existingDLFileEntryType = fetchExistingFileEntryType(fileEntryType.getUuid(),
                portletDataContext.getScopeGroupId(), fileEntryType.getFileEntryTypeKey(), preloaded);

        if (existingDLFileEntryType == null) {
            serviceContext.setUuid(fileEntryType.getUuid());

            importedDLFileEntryType = _dlFileEntryTypeLocalService.addFileEntryType(userId,
                    portletDataContext.getScopeGroupId(), fileEntryType.getFileEntryTypeKey(),
                    fileEntryType.getNameMap(), fileEntryType.getDescriptionMap(), ddmStructureIdsArray,
                    serviceContext);
        } else {
            _dlFileEntryTypeLocalService.updateFileEntryType(userId,
                    existingDLFileEntryType.getFileEntryTypeId(), fileEntryType.getNameMap(),
                    fileEntryType.getDescriptionMap(), ddmStructureIdsArray, serviceContext);

            importedDLFileEntryType = _dlFileEntryTypeLocalService
                    .fetchDLFileEntryType(existingDLFileEntryType.getFileEntryTypeId());
        }
    } else {
        importedDLFileEntryType = _dlFileEntryTypeLocalService.addFileEntryType(userId,
                portletDataContext.getScopeGroupId(), fileEntryType.getFileEntryTypeKey(),
                fileEntryType.getNameMap(), fileEntryType.getDescriptionMap(), ddmStructureIdsArray,
                serviceContext);
    }

    portletDataContext.importClassedModel(fileEntryType, importedDLFileEntryType);

    if (preloaded) {
        return;
    }

    String importedDLFileEntryDDMStructureKey = DLUtil.getDDMStructureKey(importedDLFileEntryType);

    List<DDMStructure> importedDDMStructures = importedDLFileEntryType.getDDMStructures();

    for (DDMStructure importedDDMStructure : importedDDMStructures) {
        String ddmStructureKey = importedDDMStructure.getStructureKey();

        if (!DLUtil.isAutoGeneratedDLFileEntryTypeDDMStructureKey(ddmStructureKey)) {

            continue;
        }

        if (ddmStructureKey.equals(importedDLFileEntryDDMStructureKey)) {
            continue;
        }

        com.liferay.dynamic.data.mapping.model.DDMStructure ddmStructure = _ddmStructureLocalService
                .getDDMStructure(importedDDMStructure.getStructureId());

        ddmStructure.setStructureKey(importedDLFileEntryDDMStructureKey);

        _ddmStructureLocalService.updateDDMStructure(ddmStructure);
    }
}

From source file:com.liferay.document.library.internal.exportimport.data.handler.FileEntryStagedModelDataHandler.java

License:Open Source License

@Override
protected void doImportStagedModel(PortletDataContext portletDataContext, FileEntry fileEntry)
        throws Exception {

    long userId = portletDataContext.getUserId(fileEntry.getUserUuid());

    if (!fileEntry.isDefaultRepository()) {

        // References has been automatically imported, nothing to do here

        return;/*from w  ww  . j  a v  a2 s. c  o  m*/
    }

    Map<Long, Long> folderIds = (Map<Long, Long>) portletDataContext.getNewPrimaryKeysMap(Folder.class);

    long folderId = MapUtil.getLong(folderIds, fileEntry.getFolderId(), fileEntry.getFolderId());

    long[] assetCategoryIds = portletDataContext.getAssetCategoryIds(DLFileEntry.class,
            fileEntry.getFileEntryId());
    String[] assetTagNames = portletDataContext.getAssetTagNames(DLFileEntry.class, fileEntry.getFileEntryId());

    ServiceContext serviceContext = portletDataContext.createServiceContext(fileEntry, DLFileEntry.class);

    serviceContext.setAttribute("sourceFileName", "A." + fileEntry.getExtension());
    serviceContext.setUserId(userId);

    Element fileEntryElement = portletDataContext.getImportDataElement(fileEntry);

    String binPath = fileEntryElement.attributeValue("bin-path");

    InputStream is = null;

    try {
        if (Validator.isNull(binPath) && portletDataContext.isPerformDirectBinaryImport()) {

            try {
                is = FileEntryUtil.getContentStream(fileEntry);
            } catch (Exception e) {
                if (_log.isWarnEnabled()) {
                    _log.warn("Unable to retrieve content for file entry " + fileEntry.getFileEntryId(), e);
                }

                return;
            }
        } else {
            is = portletDataContext.getZipEntryAsInputStream(binPath);
        }

        if (is == null) {
            if (_log.isWarnEnabled()) {
                _log.warn("No file found for file entry " + fileEntry.getFileEntryId());
            }

            return;
        }

        importMetaData(portletDataContext, fileEntryElement, fileEntry, serviceContext);

        FileEntry importedFileEntry = null;

        if (portletDataContext.isDataStrategyMirror()) {
            FileEntry existingFileEntry = fetchStagedModelByUuidAndGroupId(fileEntry.getUuid(),
                    portletDataContext.getScopeGroupId());

            FileVersion fileVersion = fileEntry.getFileVersion();

            if (existingFileEntry == null) {
                if (portletDataContext.isDataStrategyMirrorWithOverwriting()) {

                    FileEntry existingTitleFileEntry = FileEntryUtil
                            .fetchByR_F_T(portletDataContext.getScopeGroupId(), folderId, fileEntry.getTitle());

                    if (existingTitleFileEntry == null) {
                        existingTitleFileEntry = FileEntryUtil.fetchByR_F_FN(
                                portletDataContext.getScopeGroupId(), folderId, fileEntry.getFileName());
                    }

                    if (existingTitleFileEntry != null) {
                        _dlAppLocalService.deleteFileEntry(existingTitleFileEntry.getFileEntryId());
                    }
                }

                serviceContext.setAttribute("fileVersionUuid", fileVersion.getUuid());
                serviceContext.setUuid(fileEntry.getUuid());

                String fileEntryTitle = _dlFileEntryLocalService.getUniqueTitle(
                        portletDataContext.getScopeGroupId(), folderId, 0, fileEntry.getTitle(),
                        fileEntry.getExtension());

                importedFileEntry = _dlAppLocalService.addFileEntry(userId,
                        portletDataContext.getScopeGroupId(), folderId, fileEntry.getFileName(),
                        fileEntry.getMimeType(), fileEntryTitle, fileEntry.getDescription(), null, is,
                        fileEntry.getSize(), serviceContext);

                if (fileEntry.isInTrash()) {
                    importedFileEntry = _dlTrashService
                            .moveFileEntryToTrash(importedFileEntry.getFileEntryId());
                }
            } else {
                FileVersion latestExistingFileVersion = existingFileEntry.getLatestFileVersion(true);

                boolean indexEnabled = serviceContext.isIndexingEnabled();

                boolean deleteFileEntry = false;
                boolean updateFileEntry = false;

                if (!Objects.equals(fileVersion.getUuid(), latestExistingFileVersion.getUuid())) {

                    deleteFileEntry = true;
                    updateFileEntry = true;
                } else {
                    InputStream existingFileVersionInputStream = null;

                    try {
                        existingFileVersionInputStream = latestExistingFileVersion.getContentStream(false);
                    } catch (Exception e) {
                        if (_log.isDebugEnabled()) {
                            _log.debug(e, e);
                        }
                    } finally {
                        if (existingFileVersionInputStream != null) {
                            existingFileVersionInputStream.close();
                        }
                    }

                    if (existingFileVersionInputStream == null) {
                        updateFileEntry = true;
                    }
                }

                try {
                    serviceContext.setIndexingEnabled(false);

                    if (updateFileEntry) {
                        DLFileVersion alreadyExistingFileVersion = _dlFileVersionLocalService
                                .getFileVersionByUuidAndGroupId(fileVersion.getUuid(),
                                        existingFileEntry.getGroupId());

                        if (alreadyExistingFileVersion != null) {
                            serviceContext.setAttribute("existingDLFileVersionId",
                                    alreadyExistingFileVersion.getFileVersionId());
                        }

                        serviceContext.setUuid(fileVersion.getUuid());

                        String fileEntryTitle = _dlFileEntryLocalService.getUniqueTitle(
                                portletDataContext.getScopeGroupId(), existingFileEntry.getFolderId(),
                                existingFileEntry.getFileEntryId(), fileEntry.getTitle(),
                                fileEntry.getExtension());

                        importedFileEntry = _dlAppLocalService.updateFileEntry(userId,
                                existingFileEntry.getFileEntryId(), fileEntry.getFileName(),
                                fileEntry.getMimeType(), fileEntryTitle, fileEntry.getDescription(), null,
                                false, is, fileEntry.getSize(), serviceContext);
                    } else {
                        _dlAppLocalService.updateAsset(userId, existingFileEntry, latestExistingFileVersion,
                                assetCategoryIds, assetTagNames, null);

                        importedFileEntry = existingFileEntry;
                    }

                    if (importedFileEntry.getFolderId() != folderId) {
                        importedFileEntry = _dlAppLocalService.moveFileEntry(userId,
                                importedFileEntry.getFileEntryId(), folderId, serviceContext);
                    }

                    if (importedFileEntry instanceof LiferayFileEntry) {
                        LiferayFileEntry liferayFileEntry = (LiferayFileEntry) importedFileEntry;

                        Indexer<DLFileEntry> indexer = IndexerRegistryUtil
                                .nullSafeGetIndexer(DLFileEntry.class);

                        indexer.reindex((DLFileEntry) liferayFileEntry.getModel());
                    }

                    if (deleteFileEntry && ExportImportThreadLocal.isStagingInProcess()) {

                        _dlAppService.deleteFileVersion(latestExistingFileVersion.getFileEntryId(),
                                latestExistingFileVersion.getVersion());
                    }
                } finally {
                    serviceContext.setIndexingEnabled(indexEnabled);
                }
            }
        } else {
            String fileEntryTitle = _dlFileEntryLocalService.getUniqueTitle(
                    portletDataContext.getScopeGroupId(), folderId, 0, fileEntry.getTitle(),
                    fileEntry.getExtension());

            importedFileEntry = _dlAppLocalService.addFileEntry(userId, portletDataContext.getScopeGroupId(),
                    folderId, fileEntry.getFileName(), fileEntry.getMimeType(), fileEntryTitle,
                    fileEntry.getDescription(), null, is, fileEntry.getSize(), serviceContext);
        }

        for (DLPluggableContentDataHandler dlPluggableContentDataHandler : _serviceTrackerList) {

            dlPluggableContentDataHandler.importContent(portletDataContext, fileEntryElement, fileEntry,
                    importedFileEntry);
        }

        portletDataContext.importClassedModel(fileEntry, importedFileEntry, DLFileEntry.class);

        Map<Long, Long> fileEntryIds = (Map<Long, Long>) portletDataContext
                .getNewPrimaryKeysMap(FileEntry.class);

        fileEntryIds.put(fileEntry.getFileEntryId(), importedFileEntry.getFileEntryId());
    } finally {
        try {
            is.close();
        } catch (IOException ioe) {
            _log.error(ioe, ioe);
        }
    }
}

From source file:com.liferay.document.library.internal.exportimport.data.handler.FileEntryStagedModelDataHandler.java

License:Open Source License

protected DDMFormValues getImportDDMFormValues(PortletDataContext portletDataContext,
        Element structureFieldsElement, DDMStructure ddmStructure) throws Exception {

    String ddmFormValuesPath = structureFieldsElement.attributeValue("ddm-form-values-path");

    String serializedDDMFormValues = portletDataContext.getZipEntryAsString(ddmFormValuesPath);

    com.liferay.dynamic.data.mapping.storage.DDMFormValues ddmFormValues = _ddmFormValuesJSONDeserializer
            .deserialize(DDMBeanTranslatorUtil.translate(ddmStructure.getDDMForm()), serializedDDMFormValues);

    ddmFormValues = _ddmFormValuesExportImportContentProcessor
            .replaceImportContentReferences(portletDataContext, ddmStructure, ddmFormValues);

    return DDMBeanTranslatorUtil.translate(ddmFormValues);
}