public static Resource getResource( WebDAVRequest webDAVRequest, String rootPath, String token, long classNameId) throws WebDAVException { try { String[] pathArray = webDAVRequest.getPathArray(); if (pathArray.length == 2) { String path = rootPath + webDAVRequest.getPath(); return new BaseResourceImpl(path, StringPool.BLANK, token); } else if (pathArray.length == 3) { String type = pathArray[2]; return toResource(webDAVRequest, type, rootPath, false); } else if (pathArray.length == 4) { String type = pathArray[2]; String typeId = pathArray[3]; if (type.equals(TYPE_STRUCTURES)) { try { DDMStructure structure = null; try { structure = DDMStructureLocalServiceUtil.getStructure(GetterUtil.getLong(typeId)); } catch (NumberFormatException nfe) { structure = DDMStructureLocalServiceUtil.getStructure( webDAVRequest.getGroupId(), classNameId, typeId); } return DDMWebDavUtil.toResource(webDAVRequest, structure, rootPath, false); } catch (NoSuchStructureException nsse) { return null; } } else if (type.equals(TYPE_TEMPLATES)) { try { DDMTemplate template = null; try { template = DDMTemplateLocalServiceUtil.getTemplate(GetterUtil.getLong(typeId)); } catch (NumberFormatException nfe) { template = DDMTemplateLocalServiceUtil.getTemplate( webDAVRequest.getGroupId(), classNameId, typeId); } return DDMWebDavUtil.toResource(webDAVRequest, template, rootPath, false); } catch (NoSuchTemplateException nste) { return null; } } } return null; } catch (Exception e) { throw new WebDAVException(e); } }
@Override public void deleteStagedModel(String uuid, long groupId, String className, String extraData) throws PortalException, SystemException { DDMStructure ddmStructure = DDMStructureLocalServiceUtil.fetchDDMStructureByUuidAndGroupId(uuid, groupId); if (ddmStructure != null) { DDMStructureLocalServiceUtil.deleteStructure(ddmStructure); } }
protected void addDDMStructures( long userId, long groupId, long classNameId, String fileName, ServiceContext serviceContext) throws DocumentException, PortalException, SystemException { List<Element> structureElements = getDDMStructures(fileName); for (Element structureElement : structureElements) { boolean dynamicStructure = GetterUtil.getBoolean(structureElement.elementText("dynamic-structure")); if (dynamicStructure) { continue; } String name = structureElement.elementText("name"); String description = structureElement.elementText("description"); String ddmStructureKey = name; DDMStructure ddmStructure = DDMStructureLocalServiceUtil.fetchStructure(groupId, ddmStructureKey); if (ddmStructure != null) { continue; } Element structureElementRootElement = structureElement.element("root"); String xsd = structureElementRootElement.asXML(); Map<Locale, String> nameMap = new HashMap<Locale, String>(); nameMap.put(LocaleUtil.getDefault(), name); Map<Locale, String> descriptionMap = new HashMap<Locale, String>(); descriptionMap.put(LocaleUtil.getDefault(), description); DDMStructureLocalServiceUtil.addStructure( userId, groupId, classNameId, ddmStructureKey, nameMap, descriptionMap, xsd, "xml", DDMStructureConstants.TYPE_DEFAULT, serviceContext); } }
protected DDMStructure fetchExistingStructure( String uuid, long groupId, long classNameId, String structureKey, boolean preloaded) throws Exception { DDMStructure existingStructure = null; if (!preloaded) { existingStructure = DDMStructureLocalServiceUtil.fetchDDMStructureByUuidAndGroupId(uuid, groupId); } else { existingStructure = DDMStructureLocalServiceUtil.fetchStructure(groupId, classNameId, structureKey); } return existingStructure; }
@Override protected void validateImport( Map<String, List<StagedModel>> dependentStagedModelsMap, Group group) throws Exception { List<StagedModel> ddmStructureDependentStagedModels = dependentStagedModelsMap.get(DDMStructure.class.getSimpleName()); Assert.assertEquals(1, ddmStructureDependentStagedModels.size()); DDMStructure ddmStructure = (DDMStructure) ddmStructureDependentStagedModels.get(0); DDMStructureLocalServiceUtil.getDDMStructureByUuidAndGroupId( ddmStructure.getUuid(), group.getGroupId()); List<StagedModel> dlFileEntryTypesDependentStagedModels = dependentStagedModelsMap.get(DLFileEntryType.class.getSimpleName()); Assert.assertEquals(1, dlFileEntryTypesDependentStagedModels.size()); DLFileEntryType dlFileEntryType = (DLFileEntryType) dlFileEntryTypesDependentStagedModels.get(0); DLFileEntryTypeLocalServiceUtil.getDLFileEntryTypeByUuidAndGroupId( dlFileEntryType.getUuid(), group.getGroupId()); List<StagedModel> folderDependentStagedModels = dependentStagedModelsMap.get(DLFolder.class.getSimpleName()); Assert.assertEquals(1, folderDependentStagedModels.size()); Folder parentFolder = (Folder) folderDependentStagedModels.get(0); DLFolderLocalServiceUtil.getDLFolderByUuidAndGroupId( parentFolder.getUuid(), group.getGroupId()); }
protected void validateCompanyDependenciesImport( Map<String, List<StagedModel>> dependentStagedModelsMap, Group group) throws Exception { List<StagedModel> ddmStructureDependentStagedModels = dependentStagedModelsMap.get(DDMStructure.class.getSimpleName()); Assert.assertEquals(1, ddmStructureDependentStagedModels.size()); DDMStructure ddmStructure = (DDMStructure) ddmStructureDependentStagedModels.get(0); Assert.assertNull( "Company DDM structure dependency should not be imported", DDMStructureLocalServiceUtil.fetchDDMStructureByUuidAndGroupId( ddmStructure.getUuid(), group.getGroupId())); List<StagedModel> dlFileEntryTypesDependentStagedModels = dependentStagedModelsMap.get(DLFileEntryType.class.getSimpleName()); Assert.assertEquals(1, dlFileEntryTypesDependentStagedModels.size()); DLFileEntryType dlFileEntryType = (DLFileEntryType) dlFileEntryTypesDependentStagedModels.get(0); Assert.assertNull( "Company DL file entry should not be imported", DLFileEntryTypeLocalServiceUtil.fetchDLFileEntryTypeByUuidAndGroupId( dlFileEntryType.getUuid(), group.getGroupId())); }
protected DDMStructure getStructure(long structureId) { try { return DDMStructureLocalServiceUtil.getStructure(structureId); } catch (Exception e) { return null; } }
protected String extractDDMContent(DLFileVersion dlFileVersion, Locale locale) throws Exception { List<DLFileEntryMetadata> dlFileEntryMetadatas = DLFileEntryMetadataLocalServiceUtil.getFileVersionFileEntryMetadatas( dlFileVersion.getFileVersionId()); StringBundler sb = new StringBundler(dlFileEntryMetadatas.size()); for (DLFileEntryMetadata dlFileEntryMetadata : dlFileEntryMetadatas) { Fields fields = null; try { fields = StorageEngineUtil.getFields(dlFileEntryMetadata.getDDMStorageId()); } catch (Exception e) { } if (fields != null) { DDMStructure ddmStructure = DDMStructureLocalServiceUtil.getStructure(dlFileEntryMetadata.getDDMStructureId()); sb.append(DDMIndexerUtil.extractAttributes(ddmStructure, fields, locale)); } } return sb.toString(); }
public static boolean contains( PermissionChecker permissionChecker, long structureId, String portletId, String actionId) throws PortalException { DDMStructure structure = DDMStructureLocalServiceUtil.getStructure(structureId); return contains(permissionChecker, structure, portletId, actionId); }
@Override public void postProcessSearchQuery(BooleanQuery searchQuery, SearchContext searchContext) throws Exception { Set<DDMStructure> ddmStructuresSet = new TreeSet<DDMStructure>(); long[] groupIds = searchContext.getGroupIds(); if ((groupIds != null) && (groupIds.length > 0)) { List<DLFileEntryType> dlFileEntryTypes = DLFileEntryTypeLocalServiceUtil.getFileEntryTypes(groupIds); for (DLFileEntryType dlFileEntryType : dlFileEntryTypes) { ddmStructuresSet.addAll(dlFileEntryType.getDDMStructures()); } } Group group = GroupLocalServiceUtil.getCompanyGroup(searchContext.getCompanyId()); DDMStructure tikaRawMetadataStructure = DDMStructureLocalServiceUtil.fetchStructure( group.getGroupId(), PortalUtil.getClassNameId(RawMetadataProcessor.class), "TikaRawMetadata"); if (tikaRawMetadataStructure != null) { ddmStructuresSet.add(tikaRawMetadataStructure); } for (DDMStructure ddmStructure : ddmStructuresSet) { addSearchDDMStruture(searchQuery, searchContext, ddmStructure); } String keywords = searchContext.getKeywords(); if (Validator.isNull(keywords)) { addSearchTerm(searchQuery, searchContext, Field.DESCRIPTION, false); addSearchTerm(searchQuery, searchContext, Field.TITLE, false); addSearchTerm(searchQuery, searchContext, Field.USER_NAME, false); } addSearchTerm(searchQuery, searchContext, "extension", false); addSearchTerm(searchQuery, searchContext, "fileEntryTypeId", false); addSearchTerm(searchQuery, searchContext, "path", false); LinkedHashMap<String, Object> params = (LinkedHashMap<String, Object>) searchContext.getAttribute("params"); if (params != null) { String expandoAttributes = (String) params.get("expandoAttributes"); if (Validator.isNotNull(expandoAttributes)) { addSearchExpando(searchQuery, searchContext, expandoAttributes); } } }
@Override public void postProcessContextQuery(BooleanQuery contextQuery, SearchContext searchContext) throws Exception { addStatus(contextQuery, searchContext); if (searchContext.isIncludeAttachments()) { addRelatedClassNames(contextQuery, searchContext); } contextQuery.addRequiredTerm(Field.HIDDEN, searchContext.isIncludeAttachments()); addSearchClassTypeIds(contextQuery, searchContext); String ddmStructureFieldName = (String) searchContext.getAttribute("ddmStructureFieldName"); Serializable ddmStructureFieldValue = searchContext.getAttribute("ddmStructureFieldValue"); if (Validator.isNotNull(ddmStructureFieldName) && Validator.isNotNull(ddmStructureFieldValue)) { String[] ddmStructureFieldNameParts = StringUtil.split(ddmStructureFieldName, StringPool.SLASH); DDMStructure structure = DDMStructureLocalServiceUtil.getStructure( GetterUtil.getLong(ddmStructureFieldNameParts[1])); String fieldName = StringUtil.replaceLast( ddmStructureFieldNameParts[2], StringPool.UNDERLINE.concat(LocaleUtil.toLanguageId(searchContext.getLocale())), StringPool.BLANK); try { ddmStructureFieldValue = DDMUtil.getIndexedFieldValue(ddmStructureFieldValue, structure.getFieldType(fieldName)); } catch (StructureFieldException sfe) { } contextQuery.addRequiredTerm( ddmStructureFieldName, StringPool.QUOTE + ddmStructureFieldValue + StringPool.QUOTE); } String[] mimeTypes = (String[]) searchContext.getAttribute("mimeTypes"); if (ArrayUtil.isNotEmpty(mimeTypes)) { BooleanQuery mimeTypesQuery = BooleanQueryFactoryUtil.create(searchContext); for (String mimeType : mimeTypes) { mimeTypesQuery.addTerm( "mimeType", StringUtil.replace(mimeType, CharPool.FORWARD_SLASH, CharPool.UNDERLINE)); } contextQuery.add(mimeTypesQuery, BooleanClauseOccur.MUST); } }
@Override public String getCompleteXsd() throws PortalException, SystemException { if (getParentStructureId() == 0) { return getXsd(); } DDMStructure parentStructure = DDMStructureLocalServiceUtil.getStructure(getParentStructureId()); return _mergeXsds(getXsd(), parentStructure.getCompleteXsd()); }
public static boolean contains( PermissionChecker permissionChecker, long groupId, long classNameId, String structureKey, String actionId) throws PortalException { DDMStructure structure = DDMStructureLocalServiceUtil.getStructure(groupId, classNameId, structureKey, true); return contains(permissionChecker, structure, actionId); }
@Override protected void validateImport( Map<String, List<StagedModel>> dependentStagedModelsMap, Group group) throws Exception { List<StagedModel> dependentStagedModels = dependentStagedModelsMap.get(DDMStructure.class.getSimpleName()); Assert.assertEquals(1, dependentStagedModels.size()); DDMStructure ddmStructure = (DDMStructure) dependentStagedModels.get(0); DDMStructureLocalServiceUtil.getDDMStructureByUuidAndGroupId( ddmStructure.getUuid(), group.getGroupId()); }
protected void validateDDMStructureFields(long ddmStructureId, Fields fields) throws PortalException { DDMStructure ddmStructure = DDMStructureLocalServiceUtil.getDDMStructure(ddmStructureId); for (Field field : fields) { if (!ddmStructure.hasField(field.getName())) { throw new StorageFieldNameException(); } if (ddmStructure.getFieldRequired(field.getName()) && Validator.isNull(field.getValue())) { throw new StorageFieldRequiredException(); } } }
@Override public boolean hasField(String fieldName) throws PortalException, SystemException { Map<String, Map<String, String>> fieldsMap = getFieldsMap(); boolean hasField = fieldsMap.containsKey(fieldName); while (!hasField && (getParentStructureId() > 0)) { DDMStructure parentStructure = DDMStructureLocalServiceUtil.getStructure(getParentStructureId()); hasField = parentStructure.hasField(fieldName); } return hasField; }
private void _indexFieldsMap(String locale) throws PortalException, SystemException { Map<String, Map<String, String>> fieldsMap = _localizedFieldsMap.get(locale); Map<String, Map<String, String>> transientFieldsMap = _localizedTransientFieldsMap.get(locale); if (fieldsMap != null) { return; } if (getParentStructureId() > 0) { DDMStructure parentStructure = DDMStructureLocalServiceUtil.getStructure(getParentStructureId()); fieldsMap = parentStructure.getFieldsMap(locale); transientFieldsMap = parentStructure.getTransientFieldsMap(locale); } else { fieldsMap = new LinkedHashMap<String, Map<String, String>>(); transientFieldsMap = new LinkedHashMap<String, Map<String, String>>(); } XPath xPathSelector = SAXReaderUtil.createXPath("//dynamic-element"); List<Node> nodes = xPathSelector.selectNodes(getDocument()); for (Node node : nodes) { Element element = (Element) node; String name = element.attributeValue("name"); if (Validator.isNotNull(element.attributeValue("dataType"))) { fieldsMap.put(name, _getField(element, locale)); } else { transientFieldsMap.put(name, _getField(element, locale)); } } String[] privateFieldNames = PropsValues.DYNAMIC_DATA_MAPPING_STRUCTURE_PRIVATE_FIELD_NAMES; for (String privateFieldName : privateFieldNames) { Map<String, String> privateField = _getPrivateField(privateFieldName); fieldsMap.put(privateFieldName, privateField); } _localizedFieldsMap.put(locale, fieldsMap); _localizedTransientFieldsMap.put(locale, transientFieldsMap); }
public static int addResource(WebDAVRequest webDavRequest, long classNameId) throws Exception { String[] pathArray = webDavRequest.getPathArray(); if (pathArray.length != 4) { return HttpServletResponse.SC_FORBIDDEN; } String type = pathArray[2]; String typeId = pathArray[3]; if (type.equals(TYPE_STRUCTURES)) { HttpServletRequest request = webDavRequest.getHttpServletRequest(); String xsd = StringUtil.read(request.getInputStream()); String defaultLocale = LocalizationUtil.getDefaultLocale(xsd); Map<Locale, String> nameMap = new HashMap<Locale, String>(); nameMap.put(LocaleUtil.fromLanguageId(defaultLocale), typeId); ServiceContext serviceContext = new ServiceContext(); serviceContext.setAddGroupPermissions(true); serviceContext.setAddGuestPermissions(true); DDMStructureLocalServiceUtil.addStructure( webDavRequest.getUserId(), webDavRequest.getGroupId(), classNameId, nameMap, null, xsd, serviceContext); return HttpServletResponse.SC_CREATED; } else if (type.equals(TYPE_TEMPLATES)) { // DDM templates can not be added via WebDAV because there is no way // to know the associated class name or class PK return HttpServletResponse.SC_FORBIDDEN; } return HttpServletResponse.SC_FORBIDDEN; }
protected List<Resource> getStructures(WebDAVRequest webDAVRequest) throws Exception { List<Resource> resources = new ArrayList<>(); List<DDMStructure> ddmStructures = DDMStructureLocalServiceUtil.getStructures( webDAVRequest.getGroupId(), PortalUtil.getClassNameId(JournalArticle.class)); for (DDMStructure ddmStructure : ddmStructures) { Resource resource = DDMWebDavUtil.toResource(webDAVRequest, ddmStructure, getRootPath(), true); resources.add(resource); } return resources; }
@Override public String getStructureId() { if (_ddmTemplate.getClassPK() == 0) { return null; } try { DDMStructure ddmStructure = DDMStructureLocalServiceUtil.getStructure(_ddmTemplate.getClassPK()); return ddmStructure.getStructureKey(); } catch (Exception e) { _log.error(e, e); } return null; }
@Override protected PortletPreferences doDeleteData( PortletDataContext portletDataContext, String portletId, PortletPreferences portletPreferences) throws Exception { if (portletDataContext.addPrimaryKey(DDMPortletDataHandler.class, "deleteData")) { return portletPreferences; } DDMTemplateLocalServiceUtil.deleteTemplates(portletDataContext.getScopeGroupId()); DDMStructureLocalServiceUtil.deleteStructures(portletDataContext.getScopeGroupId()); return portletPreferences; }
@Override public void setStructureId(String structureId) { if (Validator.isNull(structureId)) { _ddmTemplate.setClassPK(0); return; } try { DDMStructure ddmStructure = DDMStructureLocalServiceUtil.getStructure( getGroupId(), PortalUtil.getClassNameId(JournalArticle.class), structureId, true); _ddmTemplate.setClassPK(ddmStructure.getPrimaryKey()); } catch (Exception e) { _log.error(e, e); } }
protected void addFileEntryTypeAttributes(Document document, DLFileVersion dlFileVersion) throws PortalException { List<DLFileEntryMetadata> dlFileEntryMetadatas = DLFileEntryMetadataLocalServiceUtil.getFileVersionFileEntryMetadatas( dlFileVersion.getFileVersionId()); for (DLFileEntryMetadata dlFileEntryMetadata : dlFileEntryMetadatas) { Fields fields = null; try { fields = StorageEngineUtil.getFields(dlFileEntryMetadata.getDDMStorageId()); } catch (Exception e) { } if (fields != null) { DDMStructure ddmStructure = DDMStructureLocalServiceUtil.getStructure(dlFileEntryMetadata.getDDMStructureId()); DDMIndexerUtil.addAttributes(document, ddmStructure, fields); } } }
@Override protected void doExportStagedModel(PortletDataContext portletDataContext, DDMStructure structure) throws Exception { Element structureElement = portletDataContext.getExportDataElement(structure); if (structure.getParentStructureId() != DDMStructureConstants.DEFAULT_PARENT_STRUCTURE_ID) { DDMStructure parentStructure = DDMStructureLocalServiceUtil.getStructure(structure.getParentStructureId()); StagedModelDataHandlerUtil.exportReferenceStagedModel( portletDataContext, structure, parentStructure, PortletDataContext.REFERENCE_TYPE_PARENT); } long defaultUserId = UserLocalServiceUtil.getDefaultUserId(structure.getCompanyId()); if (defaultUserId == structure.getUserId()) { structureElement.addAttribute("preloaded", "true"); } portletDataContext.addClassedModel( structureElement, ExportImportPathUtil.getModelPath(structure), structure); }
protected void exportImportJournalArticle(boolean companyScopeDependencies) throws Exception { JournalArticle article = null; DDMStructure ddmStructure = null; DDMTemplate ddmTemplate = null; long groupId = group.getGroupId(); Company company = CompanyLocalServiceUtil.fetchCompany(group.getCompanyId()); Group companyGroup = company.getGroup(); if (companyScopeDependencies) { groupId = companyGroup.getGroupId(); } ddmStructure = DDMStructureTestUtil.addStructure(groupId, JournalArticle.class.getName()); ddmTemplate = DDMTemplateTestUtil.addTemplate(groupId, ddmStructure.getStructureId()); String content = DDMStructureTestUtil.getSampleStructuredContent(); article = JournalTestUtil.addArticleWithXMLContent( group.getGroupId(), content, ddmStructure.getStructureKey(), ddmTemplate.getTemplateKey()); exportImportPortlet(PortletKeys.JOURNAL); int articlesCount = JournalArticleLocalServiceUtil.getArticlesCount(importedGroup.getGroupId()); Assert.assertEquals(1, articlesCount); JournalArticle groupArticle = JournalArticleLocalServiceUtil.fetchJournalArticleByUuidAndGroupId( article.getUuid(), importedGroup.getGroupId()); Assert.assertNotNull(groupArticle); groupId = importedGroup.getGroupId(); if (companyScopeDependencies) { DDMStructure importedDDMStructure = DDMStructureLocalServiceUtil.fetchDDMStructureByUuidAndGroupId( ddmStructure.getUuid(), groupId); Assert.assertNull(importedDDMStructure); DDMTemplate importedDDMTemplate = DDMTemplateLocalServiceUtil.fetchDDMTemplateByUuidAndGroupId( ddmTemplate.getUuid(), groupId); Assert.assertNull(importedDDMTemplate); groupId = companyGroup.getGroupId(); } DDMStructure dependentDDMStructure = DDMStructureLocalServiceUtil.fetchDDMStructureByUuidAndGroupId( ddmStructure.getUuid(), groupId); Assert.assertNotNull(dependentDDMStructure); DDMTemplate dependentDDMTemplate = DDMTemplateLocalServiceUtil.fetchDDMTemplateByUuidAndGroupId( ddmTemplate.getUuid(), groupId); Assert.assertNotNull(dependentDDMTemplate); Assert.assertEquals(article.getDDMStructureKey(), dependentDDMStructure.getStructureKey()); Assert.assertEquals(article.getDDMTemplateKey(), dependentDDMTemplate.getTemplateKey()); Assert.assertEquals(dependentDDMTemplate.getClassPK(), dependentDDMStructure.getStructureId()); }
@Override public void postProcessContextBooleanFilter( BooleanFilter contextBooleanFilter, SearchContext searchContext) throws Exception { addStatus(contextBooleanFilter, searchContext); if (searchContext.isIncludeAttachments()) { addRelatedClassNames(contextBooleanFilter, searchContext); } if (ArrayUtil.contains( searchContext.getFolderIds(), DLFolderConstants.DEFAULT_PARENT_FOLDER_ID)) { contextBooleanFilter.addRequiredTerm(Field.HIDDEN, searchContext.isIncludeAttachments()); } addSearchClassTypeIds(contextBooleanFilter, searchContext); String ddmStructureFieldName = (String) searchContext.getAttribute("ddmStructureFieldName"); Serializable ddmStructureFieldValue = searchContext.getAttribute("ddmStructureFieldValue"); if (Validator.isNotNull(ddmStructureFieldName) && Validator.isNotNull(ddmStructureFieldValue)) { String[] ddmStructureFieldNameParts = StringUtil.split(ddmStructureFieldName, DDMIndexer.DDM_FIELD_SEPARATOR); DDMStructure structure = DDMStructureLocalServiceUtil.getStructure( GetterUtil.getLong(ddmStructureFieldNameParts[1])); String fieldName = StringUtil.replaceLast( ddmStructureFieldNameParts[2], StringPool.UNDERLINE.concat(LocaleUtil.toLanguageId(searchContext.getLocale())), StringPool.BLANK); try { ddmStructureFieldValue = DDMUtil.getIndexedFieldValue(ddmStructureFieldValue, structure.getFieldType(fieldName)); } catch (StructureFieldException sfe) { if (_log.isDebugEnabled()) { _log.debug(sfe, sfe); } } BooleanQuery booleanQuery = new BooleanQueryImpl(); booleanQuery.addRequiredTerm( ddmStructureFieldName, StringPool.QUOTE + ddmStructureFieldValue + StringPool.QUOTE); contextBooleanFilter.add(new QueryFilter(booleanQuery)); } String[] mimeTypes = (String[]) searchContext.getAttribute("mimeTypes"); if (ArrayUtil.isNotEmpty(mimeTypes)) { BooleanFilter mimeTypesBooleanFilter = new BooleanFilter(); for (String mimeType : mimeTypes) { mimeTypesBooleanFilter.addTerm( "mimeType", StringUtil.replace(mimeType, CharPool.FORWARD_SLASH, CharPool.UNDERLINE)); } contextBooleanFilter.add(mimeTypesBooleanFilter, BooleanClauseOccur.MUST); } }
public DDMStructure getStructure() throws PortalException, SystemException { return DDMStructureLocalServiceUtil.getStructure(getStructureId()); }
@Override protected void doImportStagedModel( PortletDataContext portletDataContext, DLFileEntryType fileEntryType) throws Exception { long userId = portletDataContext.getUserId(fileEntryType.getUserUuid()); StagedModelDataHandlerUtil.importReferenceStagedModels( portletDataContext, fileEntryType, DDMStructure.class); List<Element> ddmStructureReferenceElements = portletDataContext.getReferenceElements(fileEntryType, DDMStructure.class); long[] ddmStructureIdsArray = new long[ddmStructureReferenceElements.size()]; Map<Long, Long> ddmStructureIds = (Map<Long, Long>) portletDataContext.getNewPrimaryKeysMap(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); } 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 = DLFileEntryTypeLocalServiceUtil.addFileEntryType( userId, portletDataContext.getScopeGroupId(), fileEntryType.getFileEntryTypeKey(), fileEntryType.getNameMap(), fileEntryType.getDescriptionMap(), ddmStructureIdsArray, serviceContext); } else { DLFileEntryTypeLocalServiceUtil.updateFileEntryType( userId, existingDLFileEntryType.getFileEntryTypeId(), fileEntryType.getNameMap(), fileEntryType.getDescriptionMap(), ddmStructureIdsArray, serviceContext); importedDLFileEntryType = DLFileEntryTypeLocalServiceUtil.fetchDLFileEntryType( existingDLFileEntryType.getFileEntryTypeId()); } } else { importedDLFileEntryType = DLFileEntryTypeLocalServiceUtil.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; } importedDDMStructure.setStructureKey(importedDLFileEntryDDMStructureKey); DDMStructureLocalServiceUtil.updateDDMStructure(importedDDMStructure); } }
@Override protected void doImportStagedModel(PortletDataContext portletDataContext, DDMStructure structure) throws Exception { prepareLanguagesForImport(structure); long userId = portletDataContext.getUserId(structure.getUserUuid()); if (structure.getParentStructureId() != DDMStructureConstants.DEFAULT_PARENT_STRUCTURE_ID) { StagedModelDataHandlerUtil.importReferenceStagedModel( portletDataContext, structure, DDMStructure.class, structure.getParentStructureId()); } Map<Long, Long> structureIds = (Map<Long, Long>) portletDataContext.getNewPrimaryKeysMap(DDMStructure.class); long parentStructureId = MapUtil.getLong( structureIds, structure.getParentStructureId(), structure.getParentStructureId()); Map<String, String> structureKeys = (Map<String, String>) portletDataContext.getNewPrimaryKeysMap(DDMStructure.class + ".ddmStructureKey"); ServiceContext serviceContext = portletDataContext.createServiceContext(structure); DDMStructure importedStructure = null; if (portletDataContext.isDataStrategyMirror()) { Element element = portletDataContext.getImportDataStagedModelElement(structure); boolean preloaded = GetterUtil.getBoolean(element.attributeValue("preloaded")); DDMStructure existingStructure = fetchExistingStructure( structure.getUuid(), portletDataContext.getScopeGroupId(), structure.getClassNameId(), structure.getStructureKey(), preloaded); if (existingStructure == null) { serviceContext.setUuid(structure.getUuid()); importedStructure = DDMStructureLocalServiceUtil.addStructure( userId, portletDataContext.getScopeGroupId(), parentStructureId, structure.getClassNameId(), structure.getStructureKey(), structure.getNameMap(), structure.getDescriptionMap(), structure.getXsd(), structure.getStorageType(), structure.getType(), serviceContext); } else { importedStructure = DDMStructureLocalServiceUtil.updateStructure( existingStructure.getStructureId(), parentStructureId, structure.getNameMap(), structure.getDescriptionMap(), structure.getXsd(), serviceContext); } } else { importedStructure = DDMStructureLocalServiceUtil.addStructure( userId, portletDataContext.getScopeGroupId(), parentStructureId, structure.getClassNameId(), structure.getStructureKey(), structure.getNameMap(), structure.getDescriptionMap(), structure.getXsd(), structure.getStorageType(), structure.getType(), serviceContext); } portletDataContext.importClassedModel(structure, importedStructure); structureKeys.put(structure.getStructureKey(), importedStructure.getStructureKey()); }
public void postProcessContextQuery(BooleanQuery contextQuery, SearchContext searchContext) throws Exception { if (_log.isDebugEnabled()) { _log.debug(" postProcessContextQuery()"); } Map<String, Object> params = (Map<String, Object>) searchContext.getAttribute("params"); if (params == null) { return; } Map<String, Serializable> searchByFields = (Map<String, Serializable>) params.get(SampleConstants.STRUCTURE_FIELDS); String structureKey = (String) params.get(SampleConstants.STRUCTURE_KEY); Long groupId = (Long) params.get(SampleConstants.STRUCTURE_GROUP_ID); Locale locale = searchContext.getLocale(); DDMStructure structure = DDMStructureLocalServiceUtil.fetchStructure( groupId, PortalUtil.getClassNameId(JournalArticle.class), structureKey, true); if (!isCustomSearch(structure, groupId, searchByFields)) { return; } for (String fieldName : searchByFields.keySet()) { try { Serializable value = searchByFields.get(fieldName); String indexType = structure.getFieldProperty(fieldName, "indexType"); if (Validator.isNull(indexType)) { if (_log.isDebugEnabled()) { _log.debug("fieldName " + fieldName + " is not indexable"); } continue; } // some types are stored in a special way try { value = DDMUtil.getIndexedFieldValue(value, structure.getFieldType(fieldName)); } catch (StructureFieldException sfe) { _log.error(sfe); continue; } contextQuery.addRequiredTerm( DDMIndexerUtil.encodeName(structure.getStructureId(), fieldName, locale), StringPool.QUOTE + value + StringPool.QUOTE); } catch (Exception e) { _log.error("Error processing custom search", e); } } _log.debug(contextQuery); }