Examples with ProcessExporter com.centurylink.mdw.dataaccess.ProcessExporter used on opensource projects

Example 1 with ProcessExporter

use of com.centurylink.mdw.dataaccess.ProcessExporter in project mdw-designer by CenturyLinkCloud.

the class DesignerDataAccess method exportProcess.

public String exportProcess(Long pProcessId, boolean oldNamespaces) throws DataAccessException, XmlException {
    ProcessVO processVO = loader.loadProcess(pProcessId, true);
    new ProcessWorker().convert_to_designer(processVO);
    ProcessExporter exporter = DataAccess.getProcessExporter(dbSchemaVersion, oldNamespaces ? DesignerCompatibility.getInstance() : null);
    return exporter.exportProcess(processVO, dbSchemaVersion, new ArrayList<ExternalEventVO>());
}

Example 2 with ProcessExporter

use of com.centurylink.mdw.dataaccess.ProcessExporter in project mdw-designer by CenturyLinkCloud.

the class Importer method importPackage.

public void importPackage(String xml, boolean overwrite) throws DataAccessException, RemoteException, ActionCancelledException, XmlException {
    int preexistingVersion = -1;
    System.out.println("Parsing XML...");
    importedPackageVO = parsePackageXml(xml);
    PackageVO existing = null;
    try {
        existing = dataAccess.getPackage(importedPackageVO.getPackageName());
    } catch (DataAccessException ex) {
        if (!ex.getMessage().startsWith("Package does not exist:"))
            throw ex;
    }
    if (existing != null) {
        if (existing.getVersion() == importedPackageVO.getVersion()) {
            String msg = "Target already contains Package '" + importedPackageVO.getPackageName() + "' v" + importedPackageVO.getVersionString();
            if (!overwrite)
                throw new ActionCancelledException(msg + " and overwrite argument NOT specified.");
            else
                System.out.println(msg + " -- will overwrite existing package.");
            // overwrite existing
            importedPackageVO.setPackageId(existing.getId());
            if (!isLocal())
                importedPackageVO.setVersion(0);
            preexistingVersion = existing.getVersion();
        } else if (existing.getVersion() > importedPackageVO.getVersion()) {
            String msg = "Target already contains Package '" + importedPackageVO.getPackageName() + "' v" + existing.getVersionString() + ", whose version is greater than that of the imported package.  Cannot continue.";
            throw new ActionCancelledException(msg);
        }
    }
    System.out.println("Checking elements...");
    final List<RuleSetVO> conflicts = new ArrayList<>();
    final List<RuleSetVO> conflictsWithDifferences = new ArrayList<>();
    List<ProcessVO> existingProcessVOs = new ArrayList<>();
    List<ProcessVO> processVOsToBeImported = new ArrayList<>();
    ProcessExporter exporter = null;
    System.out.println("Comparing processes...");
    for (ProcessVO importedProcessVO : importedPackageVO.getProcesses()) {
        ProcessVO existingProcess = null;
        try {
            existingProcess = dataAccess.getProcessDefinition(importedProcessVO.getProcessName(), importedProcessVO.getVersion());
        } catch (DataAccessException ex) {
            // trap process does not exist
            if (!ex.getMessage().startsWith("Process does not exist;"))
                throw ex;
        }
        if (existingProcess != null) {
            conflicts.add(existingProcess);
            if (dataAccess.getSupportedSchemaVersion() >= DataAccess.schemaVersion52) {
                // content comparison
                if (exporter == null) {
                    boolean isOldNamespaces = dataAccess.getDatabaseSchemaVersion() < DataAccess.schemaVersion55;
                    exporter = DataAccess.getProcessExporter(dataAccess.getDatabaseSchemaVersion(), isOldNamespaces ? DesignerCompatibility.getInstance() : null);
                }
                String existingProcessXml = dataAccess.getRuleSet(existingProcess.getId()).getRuleSet();
                String importedProcessXml = exporter.exportProcess(importedProcessVO, dataAccess.getDatabaseSchemaVersion(), null);
                if (dataAccess.getSupportedSchemaVersion() < DataAccess.schemaVersion55) {
                    // may need to replace old namespace prefix in existing
                    // to avoid false positives in 5.2
                    String oldNamespaceDecl = "xmlns:xs=\"http://mdw.qwest.com/XMLSchema\"";
                    int oldNsIdx = existingProcessXml.indexOf(oldNamespaceDecl);
                    if (oldNsIdx > 0) {
                        String newNamespaceDecl = "xmlns:bpm=\"http://mdw.qwest.com/XMLSchema\"";
                        existingProcessXml = existingProcessXml.substring(0, oldNsIdx) + newNamespaceDecl + importedProcessXml.substring(oldNsIdx + oldNamespaceDecl.length() + 2);
                        existingProcessXml = existingProcessXml.replaceAll("<xs:", "<bpm:");
                        existingProcessXml = existingProcessXml.replaceAll("</xs:", "</bpm:");
                    }
                }
                // avoid false positives
                existingProcessXml = existingProcessXml.replaceAll("\\s*<bpm:Attribute Name=\"REFERENCED_ACTIVITIES\".*/>", "");
                existingProcessXml = existingProcessXml.replaceAll("\\s*<bpm:Attribute Name=\"REFERENCED_PROCESSES\".*/>", "");
                existingProcessXml = existingProcessXml.replaceFirst(" packageVersion=\"0.0\"", "");
                existingProcessXml = existingProcessXml.replaceAll("\\s*<bpm:Attribute Name=\"processid\".*/>", "");
                if (!existingProcessXml.equals(importedProcessXml))
                    conflictsWithDifferences.add(existingProcess);
            }
            if (isLocal())
                processVOsToBeImported.add(importedProcessVO);
            else
                existingProcessVOs.add(existingProcess);
        } else {
            if (dataAccess.getSupportedSchemaVersion() >= DataAccess.schemaVersion52)
                // not optional
                importedProcessVO.setInRuleSet(true);
            processVOsToBeImported.add(importedProcessVO);
        }
        for (ProcessVO subProcVO : importedProcessVO.getSubProcesses()) {
            ProcessVO existingSubProc = null;
            try {
                existingSubProc = dataAccess.getProcessDefinition(subProcVO.getProcessName(), subProcVO.getVersion());
            } catch (DataAccessException ex) {
                // trap process does not exist
                if (!ex.getMessage().startsWith("Process does not exist;"))
                    throw ex;
            }
            if (existingSubProc != null) {
                conflicts.add(existingSubProc);
                existingProcessVOs.add(existingSubProc);
                if (!isLocal())
                    existingProcessVOs.add(existingSubProc);
            }
        }
    }
    List<RuleSetVO> existingRuleSets = new ArrayList<>();
    List<RuleSetVO> ruleSetsToBeImported = new ArrayList<>();
    List<RuleSetVO> emptyRuleSets = new ArrayList<>();
    if (importedPackageVO.getRuleSets() != null) {
        System.out.println("Comparing assets...");
        for (RuleSetVO importedRuleSet : importedPackageVO.getRuleSets()) {
            RuleSetVO existingAsset = null;
            if (dataAccess.getSupportedSchemaVersion() >= DataAccess.schemaVersion55) {
                // supports same-named assets in different packages
                if (existing != null) {
                    RuleSetVO latestAsset = dataAccess.getRuleSet(existing.getPackageId(), importedRuleSet.getName());
                    if (latestAsset != null && latestAsset.getVersion() >= importedRuleSet.getVersion())
                        existingAsset = latestAsset;
                }
            } else {
                existingAsset = dataAccess.getRuleSet(importedRuleSet.getName(), importedRuleSet.getLanguage(), importedRuleSet.getVersion());
            }
            if (existingAsset != null) {
                conflicts.add(existingAsset);
                if (dataAccess.getSupportedSchemaVersion() >= DataAccess.schemaVersion52) {
                    // content comparison
                    existingAsset = dataAccess.getRuleSet(existingAsset.getId());
                    String existingAssetStr = existingAsset.getRuleSet().trim();
                    String importedAssetStr = importedRuleSet.getRuleSet().trim();
                    if (!existingAsset.isBinary()) {
                        existingAssetStr = existingAssetStr.replaceAll("\r", "");
                        importedAssetStr = importedAssetStr.replaceAll("\r", "");
                    }
                    if (!existingAssetStr.equals(importedAssetStr))
                        conflictsWithDifferences.add(existingAsset);
                }
                if (isLocal())
                    ruleSetsToBeImported.add(importedRuleSet);
                else
                    existingRuleSets.add(existingAsset);
            } else if (importedRuleSet.getRuleSet().trim().isEmpty()) {
                emptyRuleSets.add(importedRuleSet);
            } else {
                ruleSetsToBeImported.add(importedRuleSet);
            }
        }
    }
    if (existing != null && importedPackageVO.getTaskTemplates() != null && existing.getTaskTemplates() != null) {
        for (TaskVO importedTask : importedPackageVO.getTaskTemplates()) {
            for (TaskVO taskTemplate : existing.getTaskTemplates()) {
                if (taskTemplate.getName().equals(importedTask.getName()) && taskTemplate.getVersion() == importedTask.getVersion()) {
                    conflicts.add(taskTemplate);
                    String existingTemplStr = taskTemplate.toTemplate().xmlText();
                    String importedTemplStr = importedTask.toTemplate().xmlText();
                    if (!existingTemplStr.equals(importedTemplStr))
                        conflictsWithDifferences.add(taskTemplate);
                }
            }
        }
    }
    if (!conflicts.isEmpty()) {
        Collections.sort(conflicts, new Comparator<RuleSetVO>() {

            public int compare(RuleSetVO rs1, RuleSetVO rs2) {
                return rs1.getLabel().compareToIgnoreCase(rs2.getLabel());
            }
        });
        String msg;
        if (isLocal())
            msg = "The following versions exist locally in '" + importedPackageVO.getPackageName() + "' and will be overwritten:";
        else
            msg = "The following versions from package '" + importedPackageVO.getPackageName() + "' will not be imported:\n(The same or later versions already exist in the target environment";
        if (dataAccess.getDatabaseSchemaVersion() >= DataAccess.schemaVersion52)
            msg += " -- * indicates content differs";
        msg += ").";
        System.out.println(msg);
        for (RuleSetVO rs : conflicts) {
            String flag = conflictsWithDifferences.contains(rs) ? " *" : "";
            System.out.println("   " + rs.getLabel() + flag);
        }
    }
    if (!emptyRuleSets.isEmpty()) {
        System.out.println("The following assets from package '" + importedPackageVO.getPackageName() + "' will not be imported because they're empty:");
        for (RuleSetVO rs : emptyRuleSets) System.out.println("   " + rs.getLabel());
    }
    importedPackageVO.setProcesses(processVOsToBeImported);
    importedPackageVO.setRuleSets(ruleSetsToBeImported);
    // designer fix for backward compatibility
    ProcessWorker worker = new ProcessWorker();
    if (importedPackageVO.getProcesses() != null) {
        NodeMetaInfo nodeMetaInfo = new NodeMetaInfo();
        nodeMetaInfo.init(dataAccess.getActivityImplementors(), dataAccess.getDatabaseSchemaVersion());
        NodeMetaInfo syncedNodeMetaInfo = syncNodeMetaInfo(nodeMetaInfo, importedPackageVO);
        for (ProcessVO p : importedPackageVO.getProcesses()) {
            worker.convert_to_designer(p);
            worker.convert_from_designer(p, syncedNodeMetaInfo);
        }
    }
    System.out.println("Saving package...");
    if (isLocal())
        dataAccess.savePackageNoAudit(importedPackageVO, ProcessPersister.PersistType.IMPORT);
    else
        dataAccess.savePackage(importedPackageVO, ProcessPersister.PersistType.IMPORT);
    if (preexistingVersion > 0)
        // reset version
        importedPackageVO.setVersion(preexistingVersion);
    if (importedPackageVO.getProcesses() != null) {
        System.out.println("Reloading processes...");
        for (ProcessVO importedProcessVO : importedPackageVO.getProcesses()) {
            ProcessVO reloaded = dataAccess.getProcessDefinition(importedProcessVO.getProcessName(), importedProcessVO.getVersion());
            importedProcessVO.setProcessId(reloaded.getProcessId());
        }
        if (dataAccess.getSupportedSchemaVersion() < DataAccess.schemaVersion52) {
            for (ProcessVO importedProcessVO : importedPackageVO.getProcesses()) updateSubProcessIdAttributes(importedProcessVO);
        }
    }
    if (!existingProcessVOs.isEmpty()) {
        // add back existing processes
        importedPackageVO.getProcesses().addAll(existingProcessVOs);
        dataAccess.savePackage(importedPackageVO);
    }
    if (importedPackageVO.getRuleSets() != null) {
        System.out.println("Reloading workflow assets");
        for (RuleSetVO importedRuleSet : importedPackageVO.getRuleSets()) {
            RuleSetVO reloaded;
            if (dataAccess.getSupportedSchemaVersion() >= DataAccess.schemaVersion55) {
                reloaded = dataAccess.getRuleSet(importedPackageVO.getId(), importedRuleSet.getName());
                if (// need to verify whether the above is
                reloaded == null)
                    // even needed
                    reloaded = dataAccess.getRuleSet(importedRuleSet.getId());
            } else {
                reloaded = dataAccess.getRuleSet(importedRuleSet.getName(), importedRuleSet.getLanguage(), importedRuleSet.getVersion());
            }
            importedRuleSet.setId(reloaded.getId());
        }
    }
    if (!existingRuleSets.isEmpty()) {
        importedPackageVO.getRuleSets().addAll(existingRuleSets);
        System.out.println("Saving Package...");
        if (isLocal())
            dataAccess.savePackageNoAudit(importedPackageVO);
        else
            dataAccess.savePackage(importedPackageVO);
    }
    if (preexistingVersion > 0 && existingProcessVOs.isEmpty() && existingRuleSets.isEmpty()) {
        System.out.println("Saving Package...");
        if (isLocal())
            // force
            dataAccess.savePackageNoAudit(importedPackageVO);
        else
            // associate
            // processes
            // force associate
            dataAccess.savePackage(importedPackageVO);
    // processes
    }
}

Example 3 with ProcessExporter

use of com.centurylink.mdw.dataaccess.ProcessExporter in project mdw-designer by CenturyLinkCloud.

the class Importer method importPackage.

public WorkflowPackage importPackage(final WorkflowProject project, final String content, final ProgressMonitor progressMonitor) throws DataAccessException, RemoteException, ActionCancelledException, JSONException, XmlException {
    CodeTimer timer = new CodeTimer("importPackage()");
    int preexistingVersion = -1;
    importedPackageVO = null;
    progressMonitor.start("Importing Package into: '" + project.getLabel() + "'");
    progressMonitor.progress(5);
    progressMonitor.subTask(PARSING_XML);
    boolean isJson = content.trim().startsWith("{");
    importedPackageVO = parsePackageContent(content);
    progressMonitor.subTask("Importing " + importedPackageVO.getLabel());
    progressMonitor.progress(10);
    final WorkflowPackage existing = project.getPackage(importedPackageVO.getPackageName());
    if (existing != null) {
        if (existing.getVersion() == importedPackageVO.getVersion()) {
            final String msg = project.getName() + " already contains Package '" + importedPackageVO.getPackageName() + "' v" + importedPackageVO.getVersionString();
            if (shell != null) {
                shell.getDisplay().syncExec(new Runnable() {

                    public void run() {
                        if (!MessageDialog.openConfirm(shell, "Import Package", msg + ".\nImport this package?"))
                            importedPackageVO = null;
                    }
                });
            } else {
                PluginMessages.log(msg);
            }
            if (importedPackageVO != null) {
                // overwrite existing
                importedPackageVO.setPackageId(existing.getId());
                if (!isLocal())
                    importedPackageVO.setVersion(0);
                preexistingVersion = existing.getVersion();
            }
        } else if (existing.getVersion() > importedPackageVO.getVersion()) {
            final String msg = project.getName() + " already contains Package '" + importedPackageVO.getPackageName() + "' v" + existing.getVersionString() + ", whose version is greater than that of the imported package.  Cannot continue.";
            if (shell != null) {
                shell.getDisplay().syncExec(new Runnable() {

                    public void run() {
                        MessageDialog.openError(shell, "Import Package", msg);
                        importedPackageVO = null;
                    }
                });
            } else {
                PluginMessages.log(msg);
            }
        }
        if (importedPackageVO == null)
            return null;
    }
    if (shell != null && progressMonitor.isCanceled())
        throw new ActionCancelledException();
    progressMonitor.progress(10);
    progressMonitor.subTask("Checking elements");
    final List<WorkflowElement> conflicts = new ArrayList<>();
    final List<WorkflowElement> conflictsWithDifferences = new ArrayList<>();
    final List<ProcessVO> existingProcessVOs = new ArrayList<>();
    List<ProcessVO> processVOsToBeImported = new ArrayList<>();
    ProcessExporter exporter = null;
    for (ProcessVO importedProcessVO : importedPackageVO.getProcesses()) {
        WorkflowProcess existingProcess = project.getProcess(importedProcessVO.getProcessName(), importedProcessVO.getVersionString());
        if (existingProcess != null) {
            conflicts.add(existingProcess);
            if (project.getDataAccess().getSupportedSchemaVersion() >= DataAccess.schemaVersion52 && MdwPlugin.getSettings().isCompareConflictingAssetsDuringImport()) {
                progressMonitor.subTask("Comparing processes (can be disabled in prefs)");
                // content comparison
                if (exporter == null)
                    exporter = DataAccess.getProcessExporter(project.getDataAccess().getSchemaVersion(), project.isOldNamespaces() ? DesignerCompatibility.getInstance() : null);
                String existingProcessXml = project.getDataAccess().loadRuleSet(existingProcess.getId()).getRuleSet();
                String importedProcessXml = isJson ? importedProcessVO.getJson().toString(2) : exporter.exportProcess(importedProcessVO, project.getDataAccess().getSchemaVersion(), null);
                if (project.getDataAccess().getSupportedSchemaVersion() < DataAccess.schemaVersion55) {
                    // may need to replace old namespace prefix in existing
                    // to avoid false positives in 5.2
                    String oldNamespaceDecl = "xmlns:xs=\"http://mdw.qwest.com/XMLSchema\"";
                    int oldNsIdx = existingProcessXml.indexOf(oldNamespaceDecl);
                    if (oldNsIdx > 0) {
                        String newNamespaceDecl = "xmlns:bpm=\"http://mdw.qwest.com/XMLSchema\"";
                        existingProcessXml = existingProcessXml.substring(0, oldNsIdx) + newNamespaceDecl + importedProcessXml.substring(oldNsIdx + oldNamespaceDecl.length() + 2);
                        existingProcessXml = existingProcessXml.replaceAll("<xs:", "<bpm:");
                        existingProcessXml = existingProcessXml.replaceAll("</xs:", "</bpm:");
                    }
                }
                // avoid false positives
                existingProcessXml = existingProcessXml.replaceAll("\\s*<bpm:Attribute Name=\"REFERENCED_ACTIVITIES\".*/>", "");
                existingProcessXml = existingProcessXml.replaceAll("\\s*<bpm:Attribute Name=\"REFERENCED_PROCESSES\".*/>", "");
                existingProcessXml = existingProcessXml.replaceFirst(" packageVersion=\"0.0\"", "");
                existingProcessXml = existingProcessXml.replaceAll("\\s*<bpm:Attribute Name=\"processid\".*/>", "");
                if (!existingProcessXml.equals(importedProcessXml))
                    conflictsWithDifferences.add(existingProcess);
            }
            if (isLocal())
                processVOsToBeImported.add(importedProcessVO);
            else
                existingProcessVOs.add(existingProcess.getProcessVO());
        } else {
            if (project.getDataAccess().getSupportedSchemaVersion() >= DataAccess.schemaVersion52)
                // not optional
                importedProcessVO.setInRuleSet(true);
            processVOsToBeImported.add(importedProcessVO);
        }
        for (ProcessVO subProcVO : importedProcessVO.getSubProcesses()) {
            WorkflowProcess existingSubProc = project.getProcess(subProcVO.getProcessName(), subProcVO.getVersionString());
            if (existingSubProc != null) {
                conflicts.add(existingSubProc);
                existingProcessVOs.add(existingSubProc.getProcessVO());
                if (!isLocal())
                    existingProcessVOs.add(existingSubProc.getProcessVO());
            }
        }
    }
    if (shell != null && progressMonitor.isCanceled())
        throw new ActionCancelledException();
    progressMonitor.progress(10);
    final List<RuleSetVO> existingRuleSets = new ArrayList<>();
    List<RuleSetVO> ruleSetsToBeImported = new ArrayList<>();
    final List<RuleSetVO> emptyRuleSets = new ArrayList<>();
    if (importedPackageVO.getRuleSets() != null) {
        for (RuleSetVO importedRuleSet : importedPackageVO.getRuleSets()) {
            WorkflowAsset existingAsset = null;
            if (dataAccess.getSupportedSchemaVersion() >= DataAccess.schemaVersion55)
                existingAsset = project.getAsset(importedPackageVO.getName(), importedRuleSet.getName(), importedRuleSet.getLanguage(), importedRuleSet.getVersion());
            else
                existingAsset = project.getAsset(importedRuleSet.getName(), importedRuleSet.getLanguage(), importedRuleSet.getVersion());
            if (existingAsset != null) {
                conflicts.add(existingAsset);
                if (project.getDataAccess().getSupportedSchemaVersion() >= DataAccess.schemaVersion52 && MdwPlugin.getSettings().isCompareConflictingAssetsDuringImport() && !existingAsset.isBinary()) {
                    progressMonitor.subTask("Comparing assets (can be disabled in prefs)");
                    // content comparison
                    existingAsset = project.getDesignerProxy().loadWorkflowAsset(existingAsset);
                    String existingAssetStr = existingAsset.getRuleSetVO().getRuleSet().trim();
                    String importedAssetStr = importedRuleSet.getRuleSet().trim();
                    if (!existingAsset.isBinary()) {
                        existingAssetStr = existingAssetStr.replaceAll("\r", "");
                        importedAssetStr = importedAssetStr.replaceAll("\r", "");
                    }
                    if (!existingAssetStr.equals(importedAssetStr))
                        conflictsWithDifferences.add(existingAsset);
                }
                if (isLocal())
                    ruleSetsToBeImported.add(importedRuleSet);
                else
                    existingRuleSets.add(existingAsset.getRuleSetVO());
            } else if (importedRuleSet.getRuleSet().trim().isEmpty()) {
                emptyRuleSets.add(importedRuleSet);
            } else {
                ruleSetsToBeImported.add(importedRuleSet);
            }
        }
    }
    if (MdwPlugin.getSettings().isCompareConflictingAssetsDuringImport() && existing != null && importedPackageVO.getTaskTemplates() != null && existing.getTaskTemplates() != null) {
        for (TaskVO importedTask : importedPackageVO.getTaskTemplates()) {
            for (TaskTemplate taskTemplate : existing.getTaskTemplates()) {
                if (taskTemplate.getName().equals(importedTask.getName()) && taskTemplate.getVersion() == importedTask.getVersion()) {
                    conflicts.add(taskTemplate);
                    String existingTemplStr = taskTemplate.getTaskVO().toTemplate().xmlText();
                    String importedTemplStr = importedTask.toTemplate().xmlText();
                    if (!existingTemplStr.equals(importedTemplStr))
                        conflictsWithDifferences.add(taskTemplate);
                }
            }
        }
    }
    if (progressMonitor.isCanceled())
        throw new ActionCancelledException();
    progressMonitor.progress(10);
    if (!conflicts.isEmpty()) {
        Collections.sort(conflicts, new Comparator<WorkflowElement>() {

            public int compare(WorkflowElement we1, WorkflowElement we2) {
                return we1.getLabel().compareToIgnoreCase(we2.getLabel());
            }
        });
        final String msg;
        if (isLocal())
            msg = "The following versions exist locally in '" + importedPackageVO.getPackageName() + "'.\nThese files in project '" + project.getName() + "' will be overwritten.\n";
        else
            msg = "The following versions from package '" + importedPackageVO.getPackageName() + "' will not be imported.\nThe same versions already exist in the '" + project.getName() + "' project.\n";
        if (shell != null) {
            shell.getDisplay().syncExec(new Runnable() {

                public void run() {
                    String msg2 = msg;
                    if (project.checkRequiredVersion(5, 2) && MdwPlugin.getSettings().isCompareConflictingAssetsDuringImport())
                        msg2 += "(Asterisk * indicates content differs.)\n";
                    int res = PluginMessages.uiList(shell, msg2, "Package Import", conflicts, conflictsWithDifferences);
                    if (res == Dialog.CANCEL)
                        importedPackageVO = null;
                }
            });
        } else {
            StringBuilder msg2 = new StringBuilder(msg);
            msg2.append(" (");
            if (project.checkRequiredVersion(5, 2))
                msg2.append(" -- * indicates content differs");
            msg2.append(").\n");
            for (WorkflowElement we : conflicts) {
                String flag = conflictsWithDifferences.contains(we) ? " *" : "";
                msg2.append("   ").append(we.getLabel()).append(flag).append("\n");
            }
            PluginMessages.log(msg2.toString());
        }
        if (importedPackageVO == null)
            return null;
    }
    if (!emptyRuleSets.isEmpty()) {
        final String msg = "The following assets from package '" + importedPackageVO.getPackageName() + "' will not be imported because they're empty.\n";
        if (shell != null) {
            shell.getDisplay().syncExec(new Runnable() {

                public void run() {
                    int res = PluginMessages.uiList(shell, msg, "Package Import", emptyRuleSets);
                    if (res == Dialog.CANCEL)
                        importedPackageVO = null;
                }
            });
        } else {
            StringBuilder msg2 = new StringBuilder(msg);
            for (RuleSetVO rs : emptyRuleSets) msg2.append("   ").append(rs.getLabel()).append("\n");
            PluginMessages.log(msg2.toString());
        }
        if (importedPackageVO == null)
            return null;
    }
    importedPackageVO.setProcesses(processVOsToBeImported);
    importedPackageVO.setRuleSets(ruleSetsToBeImported);
    // designer fix for backward compatibility
    ProcessWorker worker = new ProcessWorker();
    if (importedPackageVO.getProcesses() != null) {
        NodeMetaInfo syncedNodeMetaInfo = syncNodeMetaInfo(dataAccess.getDesignerDataModel().getNodeMetaInfo(), importedPackageVO);
        for (ProcessVO p : importedPackageVO.getProcesses()) {
            worker.convert_to_designer(p);
            worker.convert_from_designer(p, syncedNodeMetaInfo);
        }
    }
    if (shell != null && progressMonitor.isCanceled())
        throw new ActionCancelledException();
    progressMonitor.progress(10);
    progressMonitor.subTask("Saving package");
    ProcessPersister.PersistType persistType = ProcessPersister.PersistType.IMPORT;
    if (isJson && !project.checkRequiredVersion(6, 1, 1))
        persistType = ProcessPersister.PersistType.IMPORT_JSON;
    Long packageId = dataAccess.getDesignerDataAccess().savePackage(importedPackageVO, persistType);
    if (preexistingVersion > 0)
        // reset version
        importedPackageVO.setVersion(preexistingVersion);
    // for overwrite
    progressMonitor.progress(10);
    progressMonitor.subTask("Reloading processes");
    if (importedPackageVO.getProcesses() != null) {
        for (ProcessVO importedProcessVO : importedPackageVO.getProcesses()) {
            ProcessVO reloaded = dataAccess.getDesignerDataAccess().getProcessDefinition(importedProcessVO.getProcessName(), importedProcessVO.getVersion());
            importedProcessVO.setProcessId(reloaded.getProcessId());
        }
        if (project.getDataAccess().getSupportedSchemaVersion() < DataAccess.schemaVersion52) {
            for (ProcessVO importedProcessVO : importedPackageVO.getProcesses()) updateSubProcessIdAttributes(importedProcessVO);
        }
    }
    if (!existingProcessVOs.isEmpty()) {
        // add back existing processes
        importedPackageVO.getProcesses().addAll(existingProcessVOs);
        dataAccess.getDesignerDataAccess().savePackage(importedPackageVO);
    }
    progressMonitor.progress(10);
    progressMonitor.subTask("Reloading workflow assets");
    if (importedPackageVO.getRuleSets() != null) {
        for (RuleSetVO importedRuleSet : importedPackageVO.getRuleSets()) {
            RuleSetVO reloaded;
            if (dataAccess.getSupportedSchemaVersion() >= DataAccess.schemaVersion55) {
                reloaded = dataAccess.getDesignerDataAccess().getRuleSet(importedPackageVO.getId(), importedRuleSet.getName());
                if (// TODO: verify whether the above is
                reloaded == null)
                    // even needed
                    reloaded = dataAccess.getDesignerDataAccess().getRuleSet(importedRuleSet.getId());
            } else {
                reloaded = dataAccess.getDesignerDataAccess().getRuleSet(importedRuleSet.getName(), importedRuleSet.getLanguage(), importedRuleSet.getVersion());
            }
            importedRuleSet.setId(reloaded.getId());
        }
    }
    if (!existingRuleSets.isEmpty()) {
        importedPackageVO.getRuleSets().addAll(existingRuleSets);
        progressMonitor.subTask("Saving Package");
        dataAccess.getDesignerDataAccess().savePackage(importedPackageVO);
    }
    if (preexistingVersion > 0 && existingProcessVOs.isEmpty() && existingRuleSets.isEmpty()) {
        progressMonitor.subTask("Saving Package");
        // force
        dataAccess.getDesignerDataAccess().savePackage(importedPackageVO);
    // associate
    // processes
    }
    progressMonitor.progress(10);
    progressMonitor.subTask("Loading package");
    PackageVO newPackageVO = dataAccess.getDesignerDataAccess().loadPackage(packageId, false);
    WorkflowPackage importedPackage = new WorkflowPackage(project, newPackageVO);
    List<WorkflowProcess> processVersions = new ArrayList<>();
    for (ProcessVO processVO : newPackageVO.getProcesses()) {
        WorkflowProcess processVersion = new WorkflowProcess(project, processVO);
        processVersion.setPackage(importedPackage);
        processVersions.add(processVersion);
    }
    Collections.sort(processVersions);
    importedPackage.setProcesses(processVersions);
    List<ExternalEvent> externalEvents = new ArrayList<>();
    for (ExternalEventVO externalEventVO : newPackageVO.getExternalEvents()) {
        ExternalEvent externalEvent = new ExternalEvent(externalEventVO, importedPackage);
        externalEvents.add(externalEvent);
    }
    Collections.sort(externalEvents);
    importedPackage.setExternalEvents(externalEvents);
    List<TaskTemplate> taskTemplates = new ArrayList<>();
    if (newPackageVO.getTaskTemplates() != null) {
        for (TaskVO taskVO : newPackageVO.getTaskTemplates()) {
            TaskTemplate taskTemplate = new TaskTemplate(taskVO, importedPackage);
            taskTemplates.add(taskTemplate);
        }
        Collections.sort(taskTemplates);
        importedPackage.setTaskTemplates(taskTemplates);
    }
    List<ActivityImpl> activityImpls = new ArrayList<>();
    if (newPackageVO.getImplementors() != null) {
        for (ActivityImplementorVO activityImplVO : newPackageVO.getImplementors()) {
            if (importedPackageVO.getImplementors() != null) {
                // attrs not included in reload -- take from original XML
                ActivityImplementorVO xmlImplVO = null;
                for (ActivityImplementorVO implVO : importedPackageVO.getImplementors()) {
                    if (activityImplVO.getImplementorClassName().equals(implVO.getImplementorClassName()))
                        xmlImplVO = implVO;
                }
                if (xmlImplVO != null) {
                    activityImplVO.setBaseClassName(xmlImplVO.getBaseClassName());
                    activityImplVO.setIconName(xmlImplVO.getIconName());
                    activityImplVO.setShowInToolbox(xmlImplVO.isShowInToolbox());
                    activityImplVO.setLabel(xmlImplVO.getLabel());
                    activityImplVO.setAttributeDescription(xmlImplVO.getAttributeDescription());
                }
            }
            ActivityImpl activityImpl = new ActivityImpl(activityImplVO, importedPackage);
            activityImpls.add(activityImpl);
        }
        Collections.sort(activityImpls);
        importedPackage.setActivityImpls(activityImpls);
    }
    if (newPackageVO.getRuleSets() != null) {
        List<WorkflowAsset> assets = new ArrayList<>();
        for (RuleSetVO ruleSet : newPackageVO.getRuleSets()) {
            WorkflowAsset asset = WorkflowAssetFactory.createAsset(ruleSet, importedPackage);
            assets.add(asset);
        }
        Collections.sort(assets);
        importedPackage.setAssets(assets);
    }
    if (existing != null) {
        // deregister old assets
        if (existing.getAssets() != null) {
            for (WorkflowAsset oldAsset : existing.getAssets()) WorkflowAssetFactory.deRegisterAsset(oldAsset);
        }
        project.removePackage(existing);
    }
    // register new assets
    if (importedPackage.getAssets() != null) {
        for (WorkflowAsset newAsset : importedPackage.getAssets()) WorkflowAssetFactory.registerAsset(newAsset);
    }
    project.addPackage(importedPackage);
    progressMonitor.progress(10);
    dataAccess.auditLog(Action.Import, importedPackage);
    dataAccess.getPackages(true);
    dataAccess.getProcesses(true);
    dataAccess.getRuleSets(true);
    dataAccess.getActivityImplementors(true);
    project.findActivityImplementors(importedPackage);
    progressMonitor.progress(5);
    timer.stopAndLog();
    return importedPackage;
}

Example 4 with ProcessExporter

use of com.centurylink.mdw.dataaccess.ProcessExporter in project mdw-designer by CenturyLinkCloud.

the class DesignerDataAccess method exportAttributes.

public String exportAttributes(String prefix, Long artifactId, int schemaVersion, ProgressMonitor monitor, String exportArtifactType) throws DataAccessException, ActionCancelledException, XmlException {
    monitor.subTask("Loading attributes...");
    PackageVO packageVO = null;
    ProcessVO processVO = null;
    if (exportArtifactType.equals(OwnerType.PACKAGE)) {
        packageVO = loadPackage(artifactId, true);
        if (isVcsPersist()) {
            try {
                for (ProcessVO process : packageVO.getProcesses()) {
                    Map<String, String> overrideAttrs = workflowAccessRest.getAttributes(OwnerType.PROCESS, process.getId());
                    process.applyOverrideAttributes(overrideAttrs);
                }
            } catch (IOException ex) {
                throw new DataAccessOfflineException("Server does not appear to be running.", ex);
            }
        } else {
            for (ProcessVO process : packageVO.getProcesses()) {
                if (process.isInRuleSet()) {
                    Map<String, String> overrideAttrs = getAttributes(OwnerType.PROCESS, process.getId());
                    process.applyOverrideAttributes(overrideAttrs);
                }
            }
        }
    } else {
        processVO = getProcess(artifactId, null);
        if (isVcsPersist()) {
            try {
                // need to make sure attributes are retrieved
                Map<String, String> overrideAttrs = workflowAccessRest.getAttributes(OwnerType.PROCESS, processVO.getId());
                processVO.applyOverrideAttributes(overrideAttrs);
            } catch (IOException ex) {
                throw new DataAccessOfflineException("Server does not appear to be running.", ex);
            }
        }
    }
    monitor.progress(30);
    if (monitor.isCanceled())
        throw new ActionCancelledException();
    if (packageVO != null) {
        // -- subprocesses must come after their containing parent processes
        Collections.sort(packageVO.getProcesses(), new Comparator<ProcessVO>() {

            public int compare(ProcessVO pVO1, ProcessVO pVO2) {
                boolean pVO1HasSubProcs = pVO1.getSubProcesses() != null && !pVO1.getSubProcesses().isEmpty();
                boolean pVO2HasSubProcs = pVO2.getSubProcesses() != null && !pVO2.getSubProcesses().isEmpty();
                if (pVO1HasSubProcs == pVO2HasSubProcs) {
                    // sort by label
                    return pVO1.getLabel().compareToIgnoreCase(pVO2.getLabel());
                } else if (pVO1HasSubProcs)
                    return -1;
                else
                    return 1;
            }
        });
    }
    if (monitor.isCanceled())
        throw new ActionCancelledException();
    monitor.progress(5);
    monitor.subTask(EXPORTXML);
    ProcessExporter exporter = DataAccess.getProcessExporter(schemaVersion, oldNamespaces ? DesignerCompatibility.getInstance() : null);
    String xml;
    if (packageVO != null)
        xml = exporter.exportOverrideAttributes(prefix, packageVO);
    else
        xml = exporter.exportOverrideAttributes(prefix, processVO, schemaVersion);
    monitor.progress(40);
    return xml;
}

Example 5 with ProcessExporter

use of com.centurylink.mdw.dataaccess.ProcessExporter in project mdw-designer by CenturyLinkCloud.

the class DesignerDataAccess method exportPackages.

public String exportPackages(List<PackageVO> packages, int schemaVersion, boolean exportJson, boolean includeTaskTemplates, ProgressMonitor monitor) throws DataAccessException, ActionCancelledException, JSONException, XmlException {
    if (monitor != null)
        monitor.subTask("Loading package(s)...");
    List<PackageVO> loadedPackages = new ArrayList<>();
    for (PackageVO pkg : packages) {
        if (monitor != null)
            monitor.subTask("Loading " + pkg.getLabel() + "...");
        PackageVO packageVO = loadPackage(pkg.getId(), true);
        if (monitor != null)
            monitor.progress(30 / packages.size());
        if (monitor != null) {
            if (monitor.isCanceled())
                throw new ActionCancelledException();
            else
                monitor.subTask("Sorting processes and implementors");
        }
        if (packageVO.getRuleSets() != null) {
            Map<String, CustomAttributeVO> customAttrs = new HashMap<>();
            for (RuleSetVO ruleSet : packageVO.getRuleSets()) {
                if (ruleSet.getLanguage() != null && !customAttrs.containsKey(ruleSet.getLanguage())) {
                    CustomAttributeVO custAttrVO = getCustomAttribute("RULE_SET", ruleSet.getLanguage());
                    if (custAttrVO != null)
                        customAttrs.put(ruleSet.getLanguage(), custAttrVO);
                }
            }
            List<CustomAttributeVO> customAttributes = new ArrayList<>();
            for (CustomAttributeVO customAttr : customAttrs.values()) customAttributes.add(customAttr);
            packageVO.setCustomAttributes(customAttributes);
        }
        loadedPackages.add(packageVO);
    }
    if (monitor != null && monitor.isCanceled())
        throw new ActionCancelledException();
    if (monitor != null)
        monitor.progress(5);
    if (monitor != null)
        monitor.subTask(EXPORTXML);
    String export;
    if (exportJson) {
        ImporterExporterJson exporter = new ImporterExporterJson();
        export = exporter.exportPackages(loadedPackages);
    } else {
        ProcessExporter exporter = DataAccess.getProcessExporter(schemaVersion, oldNamespaces ? DesignerCompatibility.getInstance() : null);
        export = exporter.exportPackages(loadedPackages, includeTaskTemplates);
    }
    if (monitor != null)
        monitor.progress(25);
    for (PackageVO packageVO : loadedPackages) {
        packageVO.setExported(true);
        persister.persistPackage(packageVO, PersistType.UPDATE);
    }
    if (monitor != null)
        monitor.progress(15);
    return export;
}