genericeventprocessor.java

国外的一套开源CRM

                relationTitle, relatedEntityName);

        if (relatedGVL == null) {
            return STATUS_CONTINUE;
        }

        Iterator relatedGVI = relatedGVL.iterator();

        while (relatedGVI.hasNext()) {
            GenericValue relatedGV = (GenericValue) relatedGVI.next();
            int status = relatedEventProcessor.delete(userInfo, delegator,
                    entityGV.getEntityName(), relatedGV);

            if (status != STATUS_CONTINUE) {
                return status;
            }
        }

        return STATUS_CONTINUE;
    }

    /**
     * DOCUMENT ME!
     *
     * @param userInfo 
     * @param delegator 
     * @param entityGV 
     * @param relationTitle 
     * @param relatedEntityName 
     *
     * @return 
     */
    public List findOneRelated(UserInfo userInfo, GenericDelegator delegator,
        GenericValue entityGV, String relationTitle, String relatedEntityName) {
        // Find instances of a particular entity related to the current entity.  This will normally be called by
        // the deleteAllRelated method of a descendant of this class.

        GenericPK entityPK = null;

        //		String entityName = entityGV.getEntityName();
        String entityKeyString = entityGV.getPrimaryKey().toString();

        List relatedGVL = null;

        try {
            Debug.logVerbose("Retrieving all " + relatedEntityName +
                    " records related to " + entityKeyString, module);

            relatedGVL = delegator.getRelated(relationTitle +
                    relatedEntityName, entityGV);
        } catch (GenericEntityException e) {
            Debug.logError("Error getting the related " + relatedEntityName +
                " records: " + e.getLocalizedMessage(), module);

            return relatedGVL;
        }

        return relatedGVL;
    }

    //-------------------------------------------------------------------------
    // UPDATE - Updates a set of entities in the data base.
    //-------------------------------------------------------------------------
    public int processUpdate(UserInfo userInfo, GenericDelegator delegator,
        DataMatrix dataMatrix) throws GenericEntityException {

        UtilTimer timer = new UtilTimer();

        if (TIMER) {
            timer.timerString(2, "[GenericEventProcessor.processUpdate] Start");
        }

        int status = STATUS_CONTINUE;

        // Trigger the pre-update event.
        status = this.preUpdate(userInfo, delegator, dataMatrix);

        if (status != STATUS_CONTINUE) {
            return status;
        }

        if (TIMER) {
            timer.timerString(2,
                "[GenericEventProcessor.processUpdate] Preupdate finished");
        }

        // Trigger the update event.
        status = this.update(userInfo, delegator, dataMatrix);

        if (status != STATUS_CONTINUE) {
            return status;
        }

        if (TIMER) {
            timer.timerString(2,
                "[GenericEventProcessor.processUpdate] Update finished");
        }

        // Trigger the post-update event.
        status = this.postUpdate(userInfo, delegator, dataMatrix);

        if (TIMER) {
            timer.timerString(2,
                "[GenericEventProcessor.processUpdate] Postupdate finished");
        }

        if (TIMER) {
            timer.timerString(2, "[GenericEventProcessor.processUpdate] End");
        }

        return status;
    }

    /**
     * DOCUMENT ME!
     *
     * @param userInfo 
     * @param delegator 
     * @param dataMatrix 
     *
     * @return 
     */
    protected int preUpdate(UserInfo userInfo, GenericDelegator delegator,
        DataMatrix dataMatrix) {

        return STATUS_CONTINUE;
    }

    /**
     * DOCUMENT ME!
     *
     * @param userInfo 
     * @param delegator 
     * @param dataMatrix 
     *
     * @return 
     *
     * @throws GenericEntityException 
     */
    public int update(UserInfo userInfo, GenericDelegator delegator,
        DataMatrix dataMatrix) throws GenericEntityException {

        UtilTimer timer = new UtilTimer();

        if (TIMER) {
            timer.timerString(2, "[GenericEventProcessor.update] Start");
        }

        for (int row = 0; row < dataMatrix.getOriginalBuffer().getRowCount();
                row++) {
            if (TIMER) {
                timer.timerString(2, "[GenericEventProcessor.update] Saving row");
            }

            boolean rowChanged = dataMatrix.getRowChanged(row);

            if (rowChanged) {
                Vector currentRow = dataMatrix.getCurrentBuffer()
                                              .getContentsRow(row);
                Vector originalRow = dataMatrix.getOriginalBuffer()
                                               .getContentsRow(row);

                if (currentRow.size() > 0) {
                    // Create a List of generic values to be stored.
                    List storeGVL = new LinkedList();

                    // Check for updateable entities.
                    for (int entityNumber = 0;
                            entityNumber < currentRow.size(); entityNumber++) {
                        if (dataMatrix.getIsUpdateable(entityNumber)) {
                            // This entity is updateable.  Append it to the List to be stored.
                            storeGVL.add((GenericValue) currentRow.get(
                                    entityNumber));
                        }
                    }

                    Debug.logVerbose("About to update row " +
                            String.valueOf(row), module);

                    Debug.logVerbose("Generic value(s) to update: " +
                            storeGVL.toString(), module);

                    try {
                        delegator.storeAll(storeGVL);
                    } catch (GenericEntityException e2) {
                        Debug.logError("Error updating: " +
                            e2.getLocalizedMessage(), module);
                    }

                } else {
                    return STATUS_CANCEL;
                }
            }
        }

        return STATUS_CONTINUE;
    }

    /**
     * DOCUMENT ME!
     *
     * @param userInfo 
     * @param delegator 
     * @param dataMatrix 
     *
     * @return 
     */
    protected int postUpdate(UserInfo userInfo, GenericDelegator delegator,
        DataMatrix dataMatrix) {

        return STATUS_CONTINUE;
    }

    //-------------------------------------------------------------------------
    // UPDATE_SELECT - Adds and/or deletes records in a many-to-many relationship table.
    //-------------------------------------------------------------------------
    public int processUpdateSelect(UserInfo userInfo,
        GenericDelegator delegator, ModelEntity primaryModelEntity,
        ArrayList removeKeyMapList, ArrayList createKeyMapList)
        throws GenericEntityException {

        // Trigger the pre-update-select event.
        int status = this.preUpdateSelect(userInfo, delegator,
                primaryModelEntity, removeKeyMapList, createKeyMapList);

        if (status != STATUS_CONTINUE) {
            return status;
        }

        // Trigger the update-select event.
        status = this.updateSelect(userInfo, delegator, primaryModelEntity,
                removeKeyMapList, createKeyMapList);

        if (status != STATUS_CONTINUE) {
            return status;
        }

        // Trigger the post-update-select event.
        status = this.postUpdateSelect(userInfo, delegator, primaryModelEntity,
                removeKeyMapList, createKeyMapList);

        return status;
    }

    /**
     * DOCUMENT ME!
     *
     * @param userInfo 
     * @param delegator 
     * @param primaryModelEntity 
     * @param removeKeyMapList 
     * @param createKeyMapList 
     *
     * @return 
     */
    protected int preUpdateSelect(UserInfo userInfo,
        GenericDelegator delegator, ModelEntity primaryModelEntity,
        ArrayList removeKeyMapList, ArrayList createKeyMapList) {

        return STATUS_CONTINUE;
    }

    /**
     * DOCUMENT ME!
     *
     * @param userInfo 
     * @param delegator 
     * @param primaryModelEntity 
     * @param removeKeyMapList 
     * @param createKeyMapList 
     *
     * @return 
     *
     * @throws GenericEntityException 
     */
    public int updateSelect(UserInfo userInfo, GenericDelegator delegator,
        ModelEntity primaryModelEntity, ArrayList removeKeyMapList,
        ArrayList createKeyMapList) throws GenericEntityException {

        Debug.logVerbose("removeKeyMapList: " + removeKeyMapList, module);
        Debug.logVerbose("createKeyMapList: " + createKeyMapList, module);

        // Remove de-selected items from the data base.
        Iterator removeKeyMapListI = removeKeyMapList.iterator();

        while (removeKeyMapListI.hasNext()) {
            // User un-selected this item.  Need to remove it from the many-to-many table.
            HashMap removeMap = (HashMap) removeKeyMapListI.next();
            deleteOneSelect(primaryModelEntity, removeMap, userInfo, delegator);
        }

        // Add newly selected items to the data base.
        Iterator createKeyMapListI = createKeyMapList.iterator();

        while (createKeyMapListI.hasNext()) {
            // User selected this item.  Need to add it to the many-to-many table.
            HashMap createMap = (HashMap) createKeyMapListI.next();
            insertOneSelect(primaryModelEntity, createMap, userInfo, delegator);
        }

        return STATUS_CONTINUE;
    }

    /**
     * DOCUMENT ME!
     *
     * @param userInfo 
     * @param delegator 
     * @param primaryModelEntity 
     * @param removeKeyMapList 
     * @param createKeyMapList 
     *
     * @return 
     */
    protected int postUpdateSelect(UserInfo userInfo,
        GenericDelegator delegator, ModelEntity primaryModelEntity,
        ArrayList removeKeyMapList, ArrayList createKeyMapList) {

        return STATUS_CONTINUE;
    }

    /**
     * DOCUMENT ME!
     *
     * @param primaryModelEntity 
     * @param removeMap 
     * @param userInfo 
     * @param delegator 
     *
     * @return 
     */
    protected int deleteOneSelect(ModelEntity primaryModelEntity,
        HashMap removeMap, UserInfo userInfo, GenericDelegator delegator) {

        try {
            GenericPK removePK = new GenericPK(primaryModelEntity, removeMap);

            try {
                delegator.removeByPrimaryKey(removePK);
            } catch (Exception e2) {
                Debug.logError("Error removing entity using primary key map " +
                    removeMap + ": " + e2.getLocalizedMessage(), module);

                return STATUS_ERROR;
            }
        } catch (Exception e1) {
            Debug.logError("Cannot create a primary key for entity " +
                primaryModelEntity.getEntityName() + " from map " + removeMap +
                ": " + e1.getLocalizedMessage(), module);

            return STATUS_ERROR;
        }

        return STATUS_CONTINUE;
    }

    /**
     * DOCUMENT ME!
     *
     * @param primaryModelEntity 
     * @param createMap 
     * @param userInfo 
     * @param delegator 
     *
     * @return 
     */
    protected int insertOneSelect(ModelEntity primaryModelEntity,
        HashMap createMap, UserInfo userInfo, GenericDelegator delegator) {

        try {
            Debug.logVerbose("Creating generic value from " + "create map " +
                    createMap.toString(), module);

            GenericValue createGV = new GenericValue(primaryModelEntity,
                    createMap);
            createGV.setDelegator(delegator);

            try {
                Debug.logVerbose("Inserting record " + "using generic value " +
                        createGV.toString(), module);

                delegator.create(createGV);
            } catch (Exception e2) {
                Debug.logError("Error inserting a new " +
                    primaryModelEntity.getEntityName() +
                    " from generic value " + createGV, module);
                Debug.logError(e2.getLocalizedMessage(), module);

                return STATUS_ERROR;
            }
        } catch (Exception e1) {
            Debug.logError("Cannot create a generic value for entity " +
                primaryModelEntity.getEntityName() + " from map " + createMap, module);
            Debug.logError(e1.getLocalizedMessage(), module);

            return STATUS_ERROR;
        }

        return STATUS_CONTINUE;
    }

    //-------------------------------------------------------------------------
    // utility function to handle linkage between EntityAccess and the entity that is being retrieved/stored
    // the default is null, meaning that the entity is unrestricted
    // this should be overridden for any entity that needs controlled access
    //-------------------------------------------------------------------------
    public SecurityLinkInfo getSecurityLinkInfo(UserInfo userInfo,
        GenericDelegator delegator) {

        return null;
    }

    //-------------------------------------------------------------------------
    // CUSTOM - Performs one or more custom events.
    //-------------------------------------------------------------------------
    public int processCustom(UserInfo userInfo, GenericDelegator delegator,
        DataMatrix dataMatrix, String action) throws GenericEntityException {

        return STATUS_CONTINUE;
    }

    /**
     * Add entity clauses for one related entity.  This will join related tables to the query
     * during a retrieve so query values can be entered that are in related entities.
     *
     * @author  <a href='mailto:[e-mail]'>John Nutting</a>
     *
     * @param delegator Reference to the OFBIZ delegator being used to connect to the data base
     * @param relationTitle Relation title
     * @param relatedEntityName Name of related entity
     * @param primaryEntityName Name of the primary entity
     * @param primaryME ModelEntity object for the primary entity
     * @param queryInfo  criteria to be used in search
     */
    public void addOneRelationClause(GenericDelegator delegator,
        String relationTitle, String relatedAndFields, String relatedEntityName,
        String primaryEntityName, ModelEntity primaryME, boolean isOuterJoin, QueryInfo queryInfo)
        throws GenericEntityException 
    {
		EventUtility.addOneRelationClause(delegator, relationTitle, relatedAndFields, relatedEntityName, primaryEntityName, primaryME, isOuterJoin, queryInfo);
    }

}