protected void doExportStagedModel(
      PortletDataContext portletDataContext, CalendarResource calendarResource) throws Exception {

    Element calendarResourceElement = portletDataContext.getExportDataElement(calendarResource);

    for (Calendar calendar : calendarResource.getCalendars()) {
      StagedModelDataHandlerUtil.exportReferenceStagedModel(
          portletDataContext, calendarResource, calendar, PortletDataContext.REFERENCE_TYPE_STRONG);
    }

    if (calendarResource.getClassNameId() == PortalUtil.getClassNameId(User.class)) {

      User user = UserLocalServiceUtil.getUser(calendarResource.getClassPK());

      portletDataContext.addReferenceElement(
          calendarResource,
          calendarResourceElement,
          user,
          User.class,
          PortletDataContext.REFERENCE_TYPE_DEPENDENCY_DISPOSABLE,
          true);
    }

    portletDataContext.addClassedModel(
        calendarResourceElement,
        ExportImportPathUtil.getModelPath(calendarResource),
        calendarResource);
  }
  @Override
  protected void doExportStagedModel(PortletDataContext portletDataContext, DDLRecord record)
      throws Exception {

    StagedModelDataHandlerUtil.exportReferenceStagedModel(
        portletDataContext,
        record,
        record.getRecordSet(),
        PortletDataContext.REFERENCE_TYPE_STRONG);

    DDLRecordVersion recordVersion = record.getRecordVersion();

    Fields fields = StorageEngineUtil.getFields(recordVersion.getDDMStorageId());

    String fieldsPath = ExportImportPathUtil.getModelPath(record, "fields.xml");

    portletDataContext.addZipEntry(fieldsPath, fields);

    Element recordElement = portletDataContext.getExportDataElement(record);

    recordElement.addAttribute("fields-path", fieldsPath);

    portletDataContext.addClassedModel(
        recordElement, ExportImportPathUtil.getModelPath(record), record);
  }
  @Override
  protected void doExportStagedModel(PortletDataContext portletDataContext, MBMessage message)
      throws Exception {

    if ((message.getStatus() != WorkflowConstants.STATUS_APPROVED)
        || (message.getCategoryId() == MBCategoryConstants.DISCUSSION_CATEGORY_ID)) {

      return;
    }

    StagedModelDataHandlerUtil.exportStagedModel(portletDataContext, message.getCategory());

    Element messageElement = portletDataContext.getExportDataStagedModelElement(message);

    message.setPriority(message.getPriority());

    MBThread thread = message.getThread();

    messageElement.addAttribute("question", String.valueOf(thread.isQuestion()));

    boolean hasAttachmentsFileEntries = message.getAttachmentsFileEntriesCount() > 0;

    messageElement.addAttribute(
        "hasAttachmentsFileEntries", String.valueOf(hasAttachmentsFileEntries));

    if (portletDataContext.getBooleanParameter(MBPortletDataHandler.NAMESPACE, "attachments")
        && hasAttachmentsFileEntries) {

      for (FileEntry fileEntry : message.getAttachmentsFileEntries()) {
        String name = fileEntry.getTitle();
        String binPath = ExportImportPathUtil.getModelPath(message, name);

        Element attachmentElement = messageElement.addElement("attachment");

        attachmentElement.addAttribute("name", name);
        attachmentElement.addAttribute("bin-path", binPath);

        portletDataContext.addZipEntry(binPath, fileEntry.getContentStream());
      }

      long folderId = message.getAttachmentsFolderId();

      if (folderId != DLFolderConstants.DEFAULT_PARENT_FOLDER_ID) {
        message.setAttachmentsFolderId(folderId);
      }
    }

    portletDataContext.addClassedModel(
        messageElement,
        ExportImportPathUtil.getModelPath(message),
        message,
        MBPortletDataHandler.NAMESPACE);
  }
  @Override
  protected void doExportStagedModel(PortletDataContext portletDataContext, MBThreadFlag threadFlag)
      throws Exception {

    MBThread thread = MBThreadLocalServiceUtil.getThread(threadFlag.getThreadId());

    MBMessage rootMessage = MBMessageLocalServiceUtil.getMessage(thread.getRootMessageId());

    if ((rootMessage.getStatus() != WorkflowConstants.STATUS_APPROVED)
        || (rootMessage.getCategoryId() == MBCategoryConstants.DISCUSSION_CATEGORY_ID)) {

      return;
    }

    StagedModelDataHandlerUtil.exportStagedModel(portletDataContext, rootMessage);

    Element threadFlagElement = portletDataContext.getExportDataElement(threadFlag);

    threadFlagElement.addAttribute("root-message-id", String.valueOf(rootMessage.getMessageId()));

    portletDataContext.addClassedModel(
        threadFlagElement,
        ExportImportPathUtil.getModelPath(threadFlag),
        threadFlag,
        MBPortletDataHandler.NAMESPACE);
  }
Пример #5
0
  @Override
  protected void doExportStagedModel(PortletDataContext portletDataContext, DDLRecordSet recordSet)
      throws Exception {

    DDMStructure ddmStructure = recordSet.getDDMStructure();

    StagedModelDataHandlerUtil.exportStagedModel(portletDataContext, ddmStructure);

    List<DDMTemplate> ddmTemplates = ddmStructure.getTemplates();

    Element recordSetElement = portletDataContext.getExportDataElement(recordSet);

    for (DDMTemplate ddmTemplate : ddmTemplates) {
      StagedModelDataHandlerUtil.exportStagedModel(portletDataContext, ddmTemplate);

      portletDataContext.addReferenceElement(
          recordSet,
          recordSetElement,
          ddmTemplate,
          PortletDataContext.REFERENCE_TYPE_STRONG,
          false);
    }

    portletDataContext.addClassedModel(
        recordSetElement,
        ExportImportPathUtil.getModelPath(recordSet),
        recordSet,
        DDLPortletDataHandler.NAMESPACE);
  }
  @Override
  protected void doExportStagedModel(PortletDataContext portletDataContext, Repository repository)
      throws Exception {

    Element repositoryElement = portletDataContext.getExportDataElement(repository);

    Folder folder = DLAppLocalServiceUtil.getFolder(repository.getDlFolderId());

    if (folder.getModel() instanceof DLFolder) {
      DLFolder dlFolder = (DLFolder) folder.getModel();

      repositoryElement.addAttribute("hidden", String.valueOf(dlFolder.isHidden()));
    }

    portletDataContext.addClassedModel(
        repositoryElement, ExportImportPathUtil.getModelPath(repository), repository);

    List<RepositoryEntry> repositoryEntries =
        RepositoryEntryLocalServiceUtil.getRepositoryEntries(repository.getRepositoryId());

    for (RepositoryEntry repositoryEntry : repositoryEntries) {
      StagedModelDataHandlerUtil.exportReferenceStagedModel(
          portletDataContext, repository, repositoryEntry, PortletDataContext.REFERENCE_TYPE_CHILD);
    }
  }
  @Override
  protected void doExportStagedModel(
      PortletDataContext portletDataContext, DLFileEntryType fileEntryType) throws Exception {

    Element fileEntryTypeElement = portletDataContext.getExportDataElement(fileEntryType);

    List<DDMStructure> ddmStructures = fileEntryType.getDDMStructures();

    for (DDMStructure ddmStructure : ddmStructures) {
      Element referenceElement =
          StagedModelDataHandlerUtil.exportReferenceStagedModel(
              portletDataContext,
              fileEntryType,
              ddmStructure,
              PortletDataContext.REFERENCE_TYPE_STRONG);

      referenceElement.addAttribute(
          "structure-id", StringUtil.valueOf(ddmStructure.getStructureId()));
    }

    long defaultUserId = UserLocalServiceUtil.getDefaultUserId(fileEntryType.getCompanyId());

    if (defaultUserId == fileEntryType.getUserId()) {
      fileEntryTypeElement.addAttribute("preloaded", "true");
    }

    portletDataContext.addClassedModel(
        fileEntryTypeElement, ExportImportPathUtil.getModelPath(fileEntryType), fileEntryType);
  }
  @Override
  protected void doExportStagedModel(
      PortletDataContext portletDataContext, DLFileEntryType fileEntryType) throws Exception {

    Element fileEntryTypeElement = portletDataContext.getExportDataElement(fileEntryType);

    List<DDMStructure> ddmStructures = fileEntryType.getDDMStructures();

    for (DDMStructure ddmStructure : ddmStructures) {
      StagedModelDataHandlerUtil.exportStagedModel(portletDataContext, ddmStructure);

      Element referenceElement =
          portletDataContext.addReferenceElement(
              fileEntryType,
              fileEntryTypeElement,
              ddmStructure,
              PortletDataContext.REFERENCE_TYPE_STRONG,
              false);

      referenceElement.addAttribute(
          "structure-id", StringUtil.valueOf(ddmStructure.getStructureId()));
    }

    portletDataContext.addClassedModel(
        fileEntryTypeElement,
        ExportImportPathUtil.getModelPath(fileEntryType),
        fileEntryType,
        DLPortletDataHandler.NAMESPACE);
  }
  @Override
  protected void doExportStagedModel(PortletDataContext portletDataContext, Role role)
      throws Exception {

    String permissionsPath = ExportImportPathUtil.getModelPath(role, "permissions.xml");

    List<Permission> permissions =
        PermissionConverterUtil.convertPermissions(role, _permissionConversionFilter);

    String xml = portletDataContext.toXML(permissions);

    portletDataContext.addZipEntry(permissionsPath, xml);

    Element roleElement = portletDataContext.getExportDataElement(role);

    portletDataContext.addClassedModel(roleElement, ExportImportPathUtil.getModelPath(role), role);
  }
  @Override
  protected void doExportStagedModel(PortletDataContext portletDataContext, WikiNode node)
      throws Exception {

    Element nodeElement = portletDataContext.getExportDataElement(node);

    portletDataContext.addClassedModel(nodeElement, ExportImportPathUtil.getModelPath(node), node);
  }
  @Override
  protected void doExportStagedModel(PortletDataContext portletDataContext, MDRRuleGroup ruleGroup)
      throws Exception {

    Element ruleGroupElement = portletDataContext.getExportDataElement(ruleGroup);

    portletDataContext.addClassedModel(
        ruleGroupElement, ExportImportPathUtil.getModelPath(ruleGroup), ruleGroup);
  }
  @Override
  protected void doExportStagedModel(PortletDataContext portletDataContext, Address address)
      throws Exception {

    Element addressElement = portletDataContext.getExportDataElement(address);

    portletDataContext.addClassedModel(
        addressElement, ExportImportPathUtil.getModelPath(address), address);
  }
  @Override
  protected void doExportStagedModel(PortletDataContext portletDataContext, PollsVote vote)
      throws Exception {

    StagedModelDataHandlerUtil.exportReferenceStagedModel(
        portletDataContext, vote, vote.getChoice(), PortletDataContext.REFERENCE_TYPE_STRONG);

    Element voteElement = portletDataContext.getExportDataElement(vote);

    portletDataContext.addClassedModel(voteElement, ExportImportPathUtil.getModelPath(vote), vote);
  }
  @Override
  protected void doExportStagedModel(
      PortletDataContext portletDataContext, RepositoryEntry repositoryEntry) throws Exception {

    Element repositoryEntryElement = portletDataContext.getExportDataElement(repositoryEntry);

    portletDataContext.addClassedModel(
        repositoryEntryElement,
        ExportImportPathUtil.getModelPath(repositoryEntry),
        repositoryEntry);
  }
  @Override
  protected void doExportStagedModel(
      PortletDataContext portletDataContext, LayoutFriendlyURL layoutFriendlyURL) throws Exception {

    Element layoutFriendlyURLElement = portletDataContext.getExportDataElement(layoutFriendlyURL);

    portletDataContext.addClassedModel(
        layoutFriendlyURLElement,
        ExportImportPathUtil.getModelPath(layoutFriendlyURL),
        layoutFriendlyURL);
  }
  @Override
  protected void doExportStagedModel(
      PortletDataContext portletDataContext, PasswordPolicy passwordPolicy) throws Exception {

    Element passwordPolicyElement =
        portletDataContext.getExportDataStagedModelElement(passwordPolicy);

    portletDataContext.addClassedModel(
        passwordPolicyElement,
        ExportImportPathUtil.getModelPath(passwordPolicy),
        passwordPolicy,
        PasswordPolicyPortletDataHandler.NAMESPACE);
  }
  @Override
  protected void doExportStagedModel(
      PortletDataContext portletDataContext, LayoutPrototype layoutPrototype) throws Exception {

    Element layoutPrototypeElement = portletDataContext.getExportDataElement(layoutPrototype);

    exportLayouts(portletDataContext, layoutPrototype, layoutPrototypeElement);

    portletDataContext.addClassedModel(
        layoutPrototypeElement,
        ExportImportPathUtil.getModelPath(layoutPrototype),
        layoutPrototype,
        LayoutPrototypePortletDataHandler.NAMESPACE);
  }
  @Override
  protected void doExportStagedModel(PortletDataContext portletDataContext, BookmarksFolder folder)
      throws Exception {

    if (folder.getParentFolderId() != BookmarksFolderConstants.DEFAULT_PARENT_FOLDER_ID) {

      exportStagedModel(portletDataContext, folder.getParentFolder());
    }

    Element folderElement = portletDataContext.getExportDataElement(folder);

    portletDataContext.addClassedModel(
        folderElement,
        ExportImportPathUtil.getModelPath(folder),
        folder,
        BookmarksPortletDataHandler.NAMESPACE);
  }
Пример #19
0
  @Override
  protected void doExportStagedModel(PortletDataContext portletDataContext, JournalFolder folder)
      throws Exception {

    if (folder.getParentFolderId() != JournalFolderConstants.DEFAULT_PARENT_FOLDER_ID) {

      StagedModelDataHandlerUtil.exportReferenceStagedModel(
          portletDataContext,
          folder,
          folder.getParentFolder(),
          PortletDataContext.REFERENCE_TYPE_PARENT);
    }

    Element folderElement = portletDataContext.getExportDataElement(folder);

    portletDataContext.addClassedModel(
        folderElement, ExportImportPathUtil.getModelPath(folder), folder);
  }
  @Override
  protected void doExportStagedModel(PortletDataContext portletDataContext, AssetCategory category)
      throws Exception {

    if (category.getParentCategoryId() != AssetCategoryConstants.DEFAULT_PARENT_CATEGORY_ID) {

      AssetCategory parentCategory =
          AssetCategoryLocalServiceUtil.fetchAssetCategory(category.getParentCategoryId());

      StagedModelDataHandlerUtil.exportReferenceStagedModel(
          portletDataContext, category, parentCategory, PortletDataContext.REFERENCE_TYPE_PARENT);
    } else {
      AssetVocabulary vocabulary =
          AssetVocabularyLocalServiceUtil.fetchAssetVocabulary(category.getVocabularyId());

      StagedModelDataHandlerUtil.exportReferenceStagedModel(
          portletDataContext, category, vocabulary, PortletDataContext.REFERENCE_TYPE_PARENT);
    }

    Element categoryElement = portletDataContext.getExportDataElement(category);

    category.setUserUuid(category.getUserUuid());

    List<AssetCategoryProperty> categoryProperties =
        AssetCategoryPropertyLocalServiceUtil.getCategoryProperties(category.getCategoryId());

    for (AssetCategoryProperty categoryProperty : categoryProperties) {
      Element propertyElement = categoryElement.addElement("property");

      propertyElement.addAttribute("userUuid", categoryProperty.getUserUuid());
      propertyElement.addAttribute("key", categoryProperty.getKey());
      propertyElement.addAttribute("value", categoryProperty.getValue());
    }

    String categoryPath = ExportImportPathUtil.getModelPath(category);

    categoryElement.addAttribute("path", categoryPath);

    portletDataContext.addPermissions(AssetCategory.class, category.getCategoryId());

    portletDataContext.addZipEntry(categoryPath, category);
  }
  @Override
  protected void doExportStagedModel(
      PortletDataContext portletDataContext, WSRPConsumerPortlet wsrpConsumerPortlet)
      throws Exception {

    WSRPConsumer wsrpConsumer =
        WSRPConsumerLocalServiceUtil.getWSRPConsumer(wsrpConsumerPortlet.getWsrpConsumerId());

    StagedModelDataHandlerUtil.exportReferenceStagedModel(
        portletDataContext,
        wsrpConsumerPortlet,
        wsrpConsumer,
        PortletDataContext.REFERENCE_TYPE_STRONG);

    Element wsrpConsumerPortletElement =
        portletDataContext.getExportDataElement(wsrpConsumerPortlet);

    portletDataContext.addClassedModel(
        wsrpConsumerPortletElement,
        ExportImportPathUtil.getModelPath(wsrpConsumerPortlet),
        wsrpConsumerPortlet);
  }
  @Override
  protected void doImportStagedModel(PortletDataContext portletDataContext, MBThreadFlag threadFlag)
      throws Exception {

    Map<Long, Long> threadIds =
        (Map<Long, Long>) portletDataContext.getNewPrimaryKeysMap(MBThread.class);

    long threadId = MapUtil.getLong(threadIds, threadFlag.getThreadId(), threadFlag.getThreadId());

    if (threadId == threadFlag.getThreadId()) {
      Element element = portletDataContext.getImportDataStagedModelElement(threadFlag);

      long rootMessageId = GetterUtil.getLong(element.attributeValue("root-message-id"));

      String rootMessagePath =
          ExportImportPathUtil.getModelPath(
              portletDataContext, MBMessage.class.getName(), rootMessageId);

      MBMessage rootMessage = (MBMessage) portletDataContext.getZipEntryAsObject(rootMessagePath);

      StagedModelDataHandlerUtil.importStagedModel(portletDataContext, rootMessage);

      threadId = MapUtil.getLong(threadIds, threadFlag.getThreadId(), threadFlag.getThreadId());
    }

    MBThread thread = MBThreadLocalServiceUtil.fetchThread(threadId);

    if (thread == null) {
      return;
    }

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

    ServiceContext serviceContext =
        portletDataContext.createServiceContext(threadFlag, MBPortletDataHandler.NAMESPACE);

    MBThreadFlagLocalServiceUtil.addThreadFlag(userId, thread, serviceContext);
  }
Пример #23
0
  @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);
  }
  @Override
  protected void doImportStagedModel(PortletDataContext portletDataContext, MBMessage message)
      throws Exception {

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

    String userName = message.getUserName();

    Map<Long, Long> categoryIds =
        (Map<Long, Long>) portletDataContext.getNewPrimaryKeysMap(MBCategory.class);

    long parentCategoryId =
        MapUtil.getLong(categoryIds, message.getCategoryId(), message.getCategoryId());

    Map<Long, Long> threadIds =
        (Map<Long, Long>) portletDataContext.getNewPrimaryKeysMap(MBThread.class);

    long threadId = MapUtil.getLong(threadIds, message.getThreadId(), 0);

    Map<Long, Long> messageIds =
        (Map<Long, Long>) portletDataContext.getNewPrimaryKeysMap(MBMessage.class);

    long parentMessageId =
        MapUtil.getLong(messageIds, message.getParentMessageId(), message.getParentMessageId());

    Element element = portletDataContext.getImportDataStagedModelElement(message);

    List<ObjectValuePair<String, InputStream>> inputStreamOVPs =
        getAttachments(portletDataContext, element, message);

    try {
      ServiceContext serviceContext =
          portletDataContext.createServiceContext(message, MBPortletDataHandler.NAMESPACE);

      if (message.getStatus() != WorkflowConstants.STATUS_APPROVED) {
        serviceContext.setWorkflowAction(WorkflowConstants.ACTION_SAVE_DRAFT);
      }

      if ((parentCategoryId != MBCategoryConstants.DEFAULT_PARENT_CATEGORY_ID)
          && (parentCategoryId != MBCategoryConstants.DISCUSSION_CATEGORY_ID)
          && (parentCategoryId == message.getCategoryId())) {

        String categoryPath =
            ExportImportPathUtil.getModelPath(
                portletDataContext, MBCategory.class.getName(), parentCategoryId);

        MBCategory category = (MBCategory) portletDataContext.getZipEntryAsObject(categoryPath);

        StagedModelDataHandlerUtil.importStagedModel(portletDataContext, category);

        parentCategoryId =
            MapUtil.getLong(categoryIds, message.getCategoryId(), message.getCategoryId());
      }

      MBMessage importedMessage = null;

      if (portletDataContext.isDataStrategyMirror()) {
        MBMessage existingMessage =
            MBMessageUtil.fetchByUUID_G(message.getUuid(), portletDataContext.getScopeGroupId());

        if (existingMessage == null) {
          serviceContext.setUuid(message.getUuid());

          importedMessage =
              MBMessageLocalServiceUtil.addMessage(
                  userId,
                  userName,
                  portletDataContext.getScopeGroupId(),
                  parentCategoryId,
                  threadId,
                  parentMessageId,
                  message.getSubject(),
                  message.getBody(),
                  message.getFormat(),
                  inputStreamOVPs,
                  message.getAnonymous(),
                  message.getPriority(),
                  message.getAllowPingbacks(),
                  serviceContext);
        } else {
          importedMessage =
              MBMessageLocalServiceUtil.updateMessage(
                  userId,
                  existingMessage.getMessageId(),
                  message.getSubject(),
                  message.getBody(),
                  inputStreamOVPs,
                  new ArrayList<String>(),
                  message.getPriority(),
                  message.getAllowPingbacks(),
                  serviceContext);
        }
      } else {
        importedMessage =
            MBMessageLocalServiceUtil.addMessage(
                userId,
                userName,
                portletDataContext.getScopeGroupId(),
                parentCategoryId,
                threadId,
                parentMessageId,
                message.getSubject(),
                message.getBody(),
                message.getFormat(),
                inputStreamOVPs,
                message.getAnonymous(),
                message.getPriority(),
                message.getAllowPingbacks(),
                serviceContext);
      }

      importedMessage.setAnswer(message.getAnswer());

      if (importedMessage.isRoot()) {
        MBThreadLocalServiceUtil.updateQuestion(
            importedMessage.getThreadId(),
            GetterUtil.getBoolean(element.attributeValue("question")));
      }

      threadIds.put(message.getThreadId(), importedMessage.getThreadId());

      portletDataContext.importClassedModel(
          message, importedMessage, MBPortletDataHandler.NAMESPACE);
    } finally {
      for (ObjectValuePair<String, InputStream> inputStreamOVP : inputStreamOVPs) {

        InputStream inputStream = inputStreamOVP.getValue();

        StreamUtil.cleanUp(inputStream);
      }
    }
  }
  @Override
  protected void doImportStagedModel(PortletDataContext portletDataContext, BookmarksFolder folder)
      throws Exception {

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

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

    long parentFolderId =
        MapUtil.getLong(folderIds, folder.getParentFolderId(), folder.getParentFolderId());

    if ((parentFolderId != BookmarksFolderConstants.DEFAULT_PARENT_FOLDER_ID)
        && (parentFolderId == folder.getParentFolderId())) {

      String parentFolderPath =
          ExportImportPathUtil.getModelPath(
              portletDataContext, BookmarksFolder.class.getName(), parentFolderId);

      BookmarksFolder parentFolder =
          (BookmarksFolder) portletDataContext.getZipEntryAsObject(parentFolderPath);

      importStagedModel(portletDataContext, parentFolder);

      parentFolderId =
          MapUtil.getLong(folderIds, folder.getParentFolderId(), folder.getParentFolderId());
    }

    ServiceContext serviceContext =
        portletDataContext.createServiceContext(folder, BookmarksPortletDataHandler.NAMESPACE);

    BookmarksFolder importedFolder = null;

    if (portletDataContext.isDataStrategyMirror()) {
      BookmarksFolder existingFolder =
          BookmarksFolderUtil.fetchByUUID_G(folder.getUuid(), portletDataContext.getScopeGroupId());

      if (existingFolder == null) {
        serviceContext.setUuid(folder.getUuid());

        importedFolder =
            BookmarksFolderLocalServiceUtil.addFolder(
                userId, parentFolderId, folder.getName(), folder.getDescription(), serviceContext);
      } else {
        importedFolder =
            BookmarksFolderLocalServiceUtil.updateFolder(
                userId,
                existingFolder.getFolderId(),
                parentFolderId,
                folder.getName(),
                folder.getDescription(),
                false,
                serviceContext);
      }
    } else {
      importedFolder =
          BookmarksFolderLocalServiceUtil.addFolder(
              userId, parentFolderId, folder.getName(), folder.getDescription(), serviceContext);
    }

    portletDataContext.importClassedModel(
        folder, importedFolder, BookmarksPortletDataHandler.NAMESPACE);
  }
  @Override
  protected void doImportStagedModel(PortletDataContext portletDataContext, Role role)
      throws Exception {

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

    ServiceContext serviceContext = portletDataContext.createServiceContext(role);

    Role existingRole =
        RoleLocalServiceUtil.fetchRoleByUuidAndCompanyId(
            role.getUuid(), portletDataContext.getCompanyId());

    if (existingRole == null) {
      existingRole =
          RoleLocalServiceUtil.fetchRole(portletDataContext.getCompanyId(), role.getName());
    }

    Role importedRole = null;

    if (existingRole == null) {
      serviceContext.setUuid(role.getUuid());

      importedRole =
          RoleLocalServiceUtil.addRole(
              userId,
              null,
              0,
              role.getName(),
              role.getTitleMap(),
              role.getDescriptionMap(),
              role.getType(),
              role.getSubtype(),
              serviceContext);
    } else {
      importedRole =
          RoleLocalServiceUtil.updateRole(
              existingRole.getRoleId(),
              role.getName(),
              role.getTitleMap(),
              role.getDescriptionMap(),
              role.getSubtype(),
              serviceContext);

      deleteRolePermissions(portletDataContext, importedRole);
    }

    String permissionsPath = ExportImportPathUtil.getModelPath(role, "permissions.xml");

    List<Permission> permissions =
        (List<Permission>) portletDataContext.getZipEntryAsObject(permissionsPath);

    for (Permission permission : permissions) {
      if (ResourceBlockLocalServiceUtil.isSupported(permission.getName())) {

        importResourceBlock(portletDataContext, importedRole, permission);
      } else {
        importResourcePermissions(portletDataContext, importedRole, permission);
      }
    }

    portletDataContext.importClassedModel(role, importedRole);
  }
Пример #27
0
  @Override
  protected void doImportStagedModel(PortletDataContext portletDataContext, DDLRecordSet recordSet)
      throws Exception {

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

    Map<Long, Long> ddmStructureIds =
        (Map<Long, Long>) portletDataContext.getNewPrimaryKeysMap(DDMStructure.class);

    String structurePath =
        ExportImportPathUtil.getModelPath(
            portletDataContext, DDMStructure.class.getName(), recordSet.getDDMStructureId());

    DDMStructure ddmStructure =
        (DDMStructure) portletDataContext.getZipEntryAsObject(structurePath);

    StagedModelDataHandlerUtil.importStagedModel(portletDataContext, ddmStructure);

    long ddmStructureId =
        MapUtil.getLong(
            ddmStructureIds, recordSet.getDDMStructureId(), recordSet.getDDMStructureId());

    List<Element> ddmTemplateElements =
        portletDataContext.getReferenceDataElements(recordSet, DDMTemplate.class);

    for (Element ddmTemplateElement : ddmTemplateElements) {
      StagedModelDataHandlerUtil.importStagedModel(portletDataContext, ddmTemplateElement);
    }

    ServiceContext serviceContext =
        portletDataContext.createServiceContext(recordSet, DDLPortletDataHandler.NAMESPACE);

    DDLRecordSet importedRecordSet = null;

    if (portletDataContext.isDataStrategyMirror()) {
      DDLRecordSet existingRecordSet =
          DDLRecordSetUtil.fetchByUUID_G(recordSet.getUuid(), portletDataContext.getScopeGroupId());

      if (existingRecordSet == null) {
        serviceContext.setUuid(recordSet.getUuid());

        importedRecordSet =
            DDLRecordSetLocalServiceUtil.addRecordSet(
                userId,
                portletDataContext.getScopeGroupId(),
                ddmStructureId,
                recordSet.getRecordSetKey(),
                recordSet.getNameMap(),
                recordSet.getDescriptionMap(),
                recordSet.getMinDisplayRows(),
                recordSet.getScope(),
                serviceContext);
      } else {
        importedRecordSet =
            DDLRecordSetLocalServiceUtil.updateRecordSet(
                existingRecordSet.getRecordSetId(), ddmStructureId,
                recordSet.getNameMap(), recordSet.getDescriptionMap(),
                recordSet.getMinDisplayRows(), serviceContext);
      }
    } else {
      importedRecordSet =
          DDLRecordSetLocalServiceUtil.addRecordSet(
              userId,
              portletDataContext.getScopeGroupId(),
              ddmStructureId,
              recordSet.getRecordSetKey(),
              recordSet.getNameMap(),
              recordSet.getDescriptionMap(),
              recordSet.getMinDisplayRows(),
              recordSet.getScope(),
              serviceContext);
    }

    portletDataContext.importClassedModel(
        recordSet, importedRecordSet, DDLPortletDataHandler.NAMESPACE);
  }