leadhelper.java

国外的一套开源CRM

			List accountList = SecurityWrapper.findByAnd("Account", UtilMisc.toList(new EntityExpr("accountName", EntityComparisonOperator.LIKE, leadCompany)), 
					UtilMisc.toList("companyName"), userInfo, new SecurityLinkInfo("Account", "accountId", true), delegator);
					
			if ( accountList.size() < 1)
			{
			    String companyNameCanon = StringHelper.replaceAll(leadCompany, ",", "");
			    companyNameCanon = StringHelper.replaceAll(companyNameCanon, ".", "");
			    companyNameCanon = companyNameCanon.toUpperCase();
			    
			    String removeStrings[] = { " CORP", " INC" };
			    for ( int i=0; i < removeStrings.length; i++ )
			    {
			        int pos = companyNameCanon.lastIndexOf(removeStrings[i]);
			        if ( pos > 0 )
			            companyNameCanon = companyNameCanon.substring(0, pos);
			    }
			    companyNameCanon += "%";
			    
			    accountList = SecurityWrapper.findByAnd("Account", UtilMisc.toList(new EntityExpr("accountName", EntityComparisonOperator.LIKE, companyNameCanon)), 
						UtilMisc.toList("companyName"), userInfo, new SecurityLinkInfo("Account", "accountId", true), delegator);
			}
					
			return accountList;
		}
		catch ( Exception e)
		{
			Debug.logError("Error in findMatchingAccounts: " + e.getMessage(), module);
			return null;	
		}
	}

	public List findMatchingContacts(String leadFirstName, String leadLastName, UserInfo userInfo)
	{

		try {
			List contactList = delegator.findByCondition("Contact", new EntityConditionList(
					UtilMisc.toList(new EntityExpr("lastName", EntityComparisonOperator.LIKE, leadLastName),
					                new EntityExpr("firstName", EntityComparisonOperator.LIKE, leadFirstName + "%")),
					                EntityOperator.AND), null, UtilMisc.toList("lastName"));
					
			return contactList;
		}
		catch ( Exception e)
		{
			Debug.logError("Error in findMatchingAccounts: " + e.getMessage(), module);
			return null;	
		}
	}
	
	public List findMatchingContacts(String accountId, String leadFirstName, String leadLastName, UserInfo userInfo)
	{

		try {
			List contactList = delegator.findByCondition("Contact", new EntityConditionList(
					UtilMisc.toList(new EntityExpr("accountId", EntityComparisonOperator.EQUALS, accountId),
					                new EntityExpr("lastName", EntityComparisonOperator.LIKE, leadLastName),
					                new EntityExpr("firstName", EntityComparisonOperator.LIKE, leadFirstName)),
					                EntityOperator.AND), null, UtilMisc.toList("lastName"));
					
			return contactList;
		}
		catch ( Exception e)
		{
			Debug.logError("Error in findMatchingAccounts: " + e.getMessage(), module);
			return null;	
		}
	}
	
    /**
     * DOCUMENT ME!
     *
     * @param dataVector 
     * @param userInfo 
     *
     * @return 
     */
    public String getLeadAssignment(Vector dataVector, UserInfo userInfo) {
        String assignmentPartyId = null;

        ArrayList leadRules = getAssignmentRules(userInfo.getAccountId());

        if ((leadRules == null) || leadRules.isEmpty()) {
            return null;
        }

        Iterator ruleIterator = leadRules.iterator();

        while (ruleIterator.hasNext()) {
            LeadAssignmentRule rule = (LeadAssignmentRule) ruleIterator.next();

            List ruleCriteriaList = rule.getAssignmentCriteria();
            GenericValue ruleInfo = rule.getAssignmentRule();

            if ((ruleCriteriaList == null) || (ruleCriteriaList.isEmpty())) {
                continue;
            }

            Debug.logVerbose("checking rule: " + ruleInfo.getString("name"), module);

            String assignTo = null;

            if (ruleInfo != null) {
                assignTo = ruleInfo.getString("assignToPartyId");
            }

            Iterator criteriaIterator = ruleCriteriaList.iterator();

            boolean mismatch = false;

            while (criteriaIterator.hasNext()) {
                GenericValue criteria = (GenericValue) criteriaIterator.next();

                String criteriaName = criteria.getString("name");
                String fieldName = criteria.getString("fieldName");
                String operator = criteria.getString("operator");
                String value = criteria.getString("value");

                Debug.logVerbose("checking criteria: " + criteriaName +
                        " -> " + fieldName + " " + operator + " " + value, module);

                for (int i = 0; i < dataVector.size(); i++) {
                    GenericValue gv = (GenericValue) dataVector.get(i);

                    if (gv.getModelEntity().getField(fieldName) != null) {
                        String fieldValue = gv.getString(fieldName);

                        Debug.logVerbose("fieldValue = " + fieldValue, module);

                        if (!SimpleExpression.compare(fieldValue, operator,
                                    value)) {

                            Debug.logVerbose("criteria match failed", module);

                            mismatch = true;
                        }

                        break;
                    }
                }

                if (mismatch) {
                    break;
                }
            }

            if (!mismatch) {
                assignmentPartyId = assignTo;

                break;
            }
        }

        return assignmentPartyId;
    }

    /**
     * DOCUMENT ME!
     *
     * @param partyId 
     *
     * @return 
     */
    public ArrayList getAssignmentRules(String partyId) {
        Debug.logVerbose("[getAssignmentRules] partyId: " + partyId, module);
        Debug.logVerbose("[getAssignmentRules] delegator.getDelegatorName(): " +
                delegator.getDelegatorName(), module);

        GenericPK partyPK = delegator.makePK("Party",
                UtilMisc.toMap("partyId", partyId));
        ArrayList leadRules = (ArrayList) leadAssignemtRuleCache.get(partyPK);

        if (leadRules == null) {
            try {
                List ruleList = delegator.findByAndCache("LeadAssignmentRule",
                        UtilMisc.toMap("accountId", partyId),
                        UtilMisc.toList("priority"));

                if ((ruleList != null) && (!ruleList.isEmpty())) {
                    leadRules = new ArrayList();

                    Iterator i = ruleList.iterator();

                    while (i.hasNext()) {
                        GenericValue leadAssignmentRule = (GenericValue) i.next();
                        List assignmentCriteria = getAssignmentCriteria(leadAssignmentRule.getString(
                                    "leadAssignmentRuleId"));
                        leadRules.add(new LeadAssignmentRule(
                                leadAssignmentRule, assignmentCriteria));
                    }

                    leadAssignemtRuleCache.put(partyPK, leadRules);
                } else {
                        Debug.logVerbose(
                            "[getAssignmentRules] Did not find Assignment rules for party." +
                            partyId, module);
                }
            } catch (GenericEntityException e) {
                Debug.logError(e, module);
            }
        }

        return leadRules;
    }

    /**
     * DOCUMENT ME!
     *
     * @param ruleId 
     *
     * @return 
     */
    public List getAssignmentCriteria(String ruleId) {
        Debug.logVerbose("[getAssignmentCriteria] ruleId: " + ruleId, module);

        List criteriaList = null;

        try {
            criteriaList = delegator.findByAndCache("LeadAssignmentCriteria",
                    UtilMisc.toMap("leadAssignmentRuleId", ruleId),
                    UtilMisc.toList("criteriaSequence"));
        } catch (GenericEntityException e) {
            Debug.logError(e, module);
        }

        return criteriaList;
    }

    /**
     * DOCUMENT ME!
     */
    public void clearCache() {
        leadAssignemtRuleCache.clear();
    }

    /**
     * DOCUMENT ME!
     *
     */
    public class LeadAssignmentRule {
        GenericValue assignmentRule_ = null;
        List assignmentCriteria_ = null;

        public LeadAssignmentRule(GenericValue assignmentRule,
            List assignmentCriteria) {
            assignmentRule_ = assignmentRule;
            assignmentCriteria_ = assignmentCriteria;
        }

        /**
         * DOCUMENT ME!
         *
         * @return 
         */
        public List getAssignmentCriteria() {
            return assignmentCriteria_;
        }

        /**
         * DOCUMENT ME!
         *
         * @return 
         */
        public GenericValue getAssignmentRule() {
            return assignmentRule_;
        }

        /**
         * DOCUMENT ME!
         *
         * @param assignmentCriteria 
         */
        public void setAssignmentCriteria(List assignmentCriteria) {
            assignmentCriteria_ = assignmentCriteria;
        }

        /**
         * DOCUMENT ME!
         *
         * @param assignmentRule 
         */
        public void setAssginmentRule(GenericValue assignmentRule) {
            assignmentRule_ = assignmentRule;
        }
    }
}