xpdlreader.java

国外的一套开源CRM

                if (gvCheck != null) {
                    message = "[xpdl] Package: " + valueObject.getString("packageId") +
                            " (ver " + valueObject.getString("packageVersion") +
                            ") has already been imported. Will not update/import.";
                }
            } else if (prefix.equals("process")) {
                GenericValue gvCheck = valueObject.getDelegator().findByPrimaryKey("WorkflowProcess",
                        UtilMisc.toMap("packageId", valueObject.getString("packageId"),
                            "packageVersion", valueObject.getString("packageVersion"),
                            "processId", valueObject.getString("processId"),
                            "processVersion", valueObject.getString("processVersion")));

                if (gvCheck != null) {
                    message = "[xpdl] Process: " + valueObject.getString("processId") +
                            " (ver " + valueObject.getString("processVersion") +
                            ") has already been imported. Not importing.";
                }
            }
            if (message.length() > 0) {
                StringBuffer lines = new StringBuffer();

                for (int i = 0; i < message.length(); i++) {
                    lines.append("-");
                }
                Debug.logWarning(lines.toString(), module);
                Debug.logWarning(message, module);
                Debug.logWarning(lines.toString(), module);
                return false;
            }
        } catch (GenericEntityException e) {
            return false;
        }
        return true;
    }

    protected void readResponsibles(List responsibles, GenericValue valueObject, String prefix) throws DefinitionParserException {
        if (responsibles == null || responsibles.size() == 0)
            return;

        Long nextSeqId = delegator.getNextSeqId("WorkflowParticipantList");

        if (nextSeqId == null)
            throw new DefinitionParserException("Could not get next sequence id from data source");
        String responsibleListId = nextSeqId.toString();

        valueObject.set("responsibleListId", responsibleListId);

        Iterator responsibleIter = responsibles.iterator();
        int responsibleIndex = 1;

        while (responsibleIter.hasNext()) {
            Element responsibleElement = (Element) responsibleIter.next();
            String responsibleId = UtilXml.elementValue(responsibleElement);
            GenericValue participantListValue = delegator.makeValue("WorkflowParticipantList", null);

            participantListValue.set("packageId", valueObject.getString("packageId"));
            participantListValue.set("packageVersion", valueObject.getString("packageVersion"));
            participantListValue.set("participantListId", responsibleListId);
            participantListValue.set("participantId", responsibleId);
            participantListValue.set("participantIndex", new Long(responsibleIndex));
            if (prefix.equals("process")) {
                participantListValue.set("processId", valueObject.getString("processId"));
                participantListValue.set("processVersion", valueObject.getString("processVersion"));
            } else {
                participantListValue.set("processId", "_NA_");
                participantListValue.set("processVersion", "_NA_");
            }
            values.add(participantListValue);                      
            responsibleIndex++;
        }
    }

    protected void readExternalPackages(List externalPackages, String packageId, String packageVersion) {
        if (externalPackages == null || externalPackages.size() == 0)
            return;
        Iterator externalPackageIter = externalPackages.iterator();

        while (externalPackageIter.hasNext()) {
            Element externalPackageElement = (Element) externalPackageIter.next();
            GenericValue externalPackageValue = delegator.makeValue("WorkflowPackageExternal", null);

            values.add(externalPackageValue);
            externalPackageValue.set("packageId", packageId);
            externalPackageValue.set("packageVersion", packageVersion);
            externalPackageValue.set("externalPackageId", externalPackageElement.getAttribute("href"));
        }
    }

    protected void readTypeDeclarations(List typeDeclarations, String packageId, String packageVersion) throws DefinitionParserException {
        if (typeDeclarations == null || typeDeclarations.size() == 0)
            return;
        Iterator typeDeclarationsIter = typeDeclarations.iterator();

        while (typeDeclarationsIter.hasNext()) {
            Element typeDeclarationElement = (Element) typeDeclarationsIter.next();
            GenericValue typeDeclarationValue = delegator.makeValue("WorkflowTypeDeclaration", null);

            values.add(typeDeclarationValue);

            typeDeclarationValue.set("packageId", packageId);
            typeDeclarationValue.set("packageVersion", packageVersion);
            typeDeclarationValue.set("typeId", typeDeclarationElement.getAttribute("Id"));
            typeDeclarationValue.set("typeName", typeDeclarationElement.getAttribute("Name"));

            // (%Type;)
            readType(typeDeclarationElement, typeDeclarationValue);

            // Description?
            typeDeclarationValue.set("description", UtilXml.childElementValue(typeDeclarationElement, "Description"));
        }
    }

    // ----------------------------------------------------------------
    // Process
    // ----------------------------------------------------------------

    protected void readWorkflowProcesses(List workflowProcesses, String packageId, String packageVersion) throws DefinitionParserException {
        if (workflowProcesses == null || workflowProcesses.size() == 0)
            return;
        Iterator workflowProcessIter = workflowProcesses.iterator();

        while (workflowProcessIter.hasNext()) {
            Element workflowProcessElement = (Element) workflowProcessIter.next();

            readWorkflowProcess(workflowProcessElement, packageId, packageVersion);
        }
    }

    protected void readWorkflowProcess(Element workflowProcessElement, String packageId, String packageVersion) throws DefinitionParserException {
        GenericValue workflowProcessValue = delegator.makeValue("WorkflowProcess", null);

        values.add(workflowProcessValue);

        String processId = workflowProcessElement.getAttribute("Id");

        workflowProcessValue.set("packageId", packageId);
        workflowProcessValue.set("packageVersion", packageVersion);
        workflowProcessValue.set("processId", processId);
        workflowProcessValue.set("objectName", workflowProcessElement.getAttribute("Name"));

        // ProcessHeader
        Element processHeaderElement = UtilXml.firstChildElement(workflowProcessElement, "ProcessHeader");

        if (processHeaderElement != null) {
            // TODO: add prefix to duration Unit or map it to make it a real uomId
            workflowProcessValue.set("durationUomId", processHeaderElement.getAttribute("DurationUnit"));
            String createdStr = UtilXml.childElementValue(processHeaderElement, "Created");

            if (createdStr != null) {
                try {
                    workflowProcessValue.set("creationDateTime", java.sql.Timestamp.valueOf(createdStr));
                } catch (IllegalArgumentException e) {
                    throw new DefinitionParserException("Invalid Date-Time format in WorkflowProcess->ProcessHeader->Created: " + createdStr, e);
                }
            }
            workflowProcessValue.set("description", UtilXml.childElementValue(processHeaderElement, "Description"));

            String priorityStr = UtilXml.childElementValue(processHeaderElement, "Priority");

            if (priorityStr != null) {
                try {
                    workflowProcessValue.set("objectPriority", Long.valueOf(priorityStr));
                } catch (NumberFormatException e) {
                    throw new DefinitionParserException("Invalid whole number format in WorkflowProcess->ProcessHeader->Priority: " + priorityStr, e);
                }
            }
            String limitStr = UtilXml.childElementValue(processHeaderElement, "Limit");

            if (limitStr != null) {
                try {
                    workflowProcessValue.set("timeLimit", Double.valueOf(limitStr));
                } catch (NumberFormatException e) {
                    throw new DefinitionParserException("Invalid decimal number format in WorkflowProcess->ProcessHeader->Limit: " + limitStr, e);
                }
            }

            String validFromStr = UtilXml.childElementValue(processHeaderElement, "ValidFrom");

            if (validFromStr != null) {
                try {
                    workflowProcessValue.set("validFromDate", java.sql.Timestamp.valueOf(validFromStr));
                } catch (IllegalArgumentException e) {
                    throw new DefinitionParserException("Invalid Date-Time format in WorkflowProcess->ProcessHeader->ValidFrom: " + validFromStr, e);
                }
            }
            String validToStr = UtilXml.childElementValue(processHeaderElement, "ValidTo");

            if (validToStr != null) {
                try {
                    workflowProcessValue.set("validToDate", java.sql.Timestamp.valueOf(validToStr));
                } catch (IllegalArgumentException e) {
                    throw new DefinitionParserException("Invalid Date-Time format in WorkflowProcess->ProcessHeader->ValidTo: " + validToStr, e);
                }
            }

            // TimeEstimation?
            Element timeEstimationElement = UtilXml.firstChildElement(processHeaderElement, "TimeEstimation");

            if (timeEstimationElement != null) {
                String waitingTimeStr = UtilXml.childElementValue(timeEstimationElement, "WaitingTime");

                if (waitingTimeStr != null) {
                    try {
                        workflowProcessValue.set("waitingTime", Double.valueOf(waitingTimeStr));
                    } catch (NumberFormatException e) {
                        throw new DefinitionParserException("Invalid decimal number format in WorkflowProcess->ProcessHeader->TimeEstimation->WaitingTime: " + waitingTimeStr, e);
                    }
                }
                String workingTimeStr = UtilXml.childElementValue(timeEstimationElement, "WorkingTime");

                if (workingTimeStr != null) {
                    try {
                        workflowProcessValue.set("waitingTime", Double.valueOf(workingTimeStr));
                    } catch (NumberFormatException e) {
                        throw new DefinitionParserException("Invalid decimal number format in WorkflowProcess->ProcessHeader->TimeEstimation->WorkingTime: " + workingTimeStr, e);
                    }
                }
                String durationStr = UtilXml.childElementValue(timeEstimationElement, "Duration");

                if (durationStr != null) {
                    try {
                        workflowProcessValue.set("duration", Double.valueOf(durationStr));
                    } catch (NumberFormatException e) {
                        throw new DefinitionParserException("Invalid decimal number format in WorkflowProcess->ProcessHeader->TimeEstimation->Duration: " + durationStr, e);
                    }
                }
            }
        }

        // RedefinableHeader?
        Element redefinableHeaderElement = UtilXml.firstChildElement(workflowProcessElement, "RedefinableHeader");
        boolean processOk = readRedefinableHeader(redefinableHeaderElement, workflowProcessValue, "process");
        String processVersion = workflowProcessValue.getString("processVersion");        

        if (!processOk) {
            values.remove(workflowProcessValue);
            return;
        }

        // FormalParameters?
        Element formalParametersElement = UtilXml.firstChildElement(workflowProcessElement, "FormalParameters");
        List formalParameters = UtilXml.childElementList(formalParametersElement, "FormalParameter");

        readFormalParameters(formalParameters, packageId, packageVersion, processId, processVersion, "_NA_");

        // (%Type;)* TODO

        // DataFields?
        Element dataFieldsElement = UtilXml.firstChildElement(workflowProcessElement, "DataFields");
        List dataFields = UtilXml.childElementList(dataFieldsElement, "DataField");

        readDataFields(dataFields, packageId, packageVersion, processId, processVersion);

        // Participants?
        Element participantsElement = UtilXml.firstChildElement(workflowProcessElement, "Participants");
        List participants = UtilXml.childElementList(participantsElement, "Participant");

        readParticipants(participants, packageId, packageVersion, processId, processVersion, workflowProcessValue);

        // Applications?