PHP CRM_Contact_DAO_Relationship::find方法代码示例

 /**
  * View details of a relationship
  *
  * @return void
  *
  * @access public
  */
 function view()
 {
     require_once 'CRM/Core/DAO.php';
     $viewRelationship = CRM_Contact_BAO_Relationship::getRelationship($this->_contactId, null, null, null, $this->_id);
     //To check whether selected contact is a contact_id_a in
     //relationship type 'a_b' in relationship table, if yes then
     //revert the permissionship text in template
     $relationship = new CRM_Contact_DAO_Relationship();
     $relationship->id = $viewRelationship[$this->_id]['id'];
     if ($relationship->find(true)) {
         if ($viewRelationship[$this->_id]['rtype'] == 'a_b' && $this->_contactId == $relationship->contact_id_a) {
             $this->assign("is_contact_id_a", true);
         }
     }
     $relType = $viewRelationship[$this->_id]['civicrm_relationship_type_id'];
     $this->assign('viewRelationship', $viewRelationship);
     $employerId = CRM_Core_DAO::getFieldValue('CRM_Contact_DAO_Contact', $this->_contactId, 'employer_id');
     $this->assign('isCurrentEmployer', false);
     if ($viewRelationship[$this->_id]['employer_id'] == $this->_contactId) {
         $this->assign('isCurrentEmployer', true);
     } else {
         if ($relType == 4 && $viewRelationship[$this->_id]['cid'] == $employerId) {
             // make sure we are viewing employee of relationship
             $this->assign('isCurrentEmployer', true);
         }
     }
     $viewNote = CRM_Core_BAO_Note::getNote($this->_id);
     $this->assign('viewNote', $viewNote);
     $groupTree =& CRM_Core_BAO_CustomGroup::getTree('Relationship', $this, $this->_id, 0, $relType);
     CRM_Core_BAO_CustomGroup::buildCustomDataView($this, $groupTree);
     $rType = CRM_Utils_Array::value('rtype', $viewRelationship[$this->_id]);
     // add viewed contribution to recent items list
     require_once 'CRM/Utils/Recent.php';
     $url = CRM_Utils_System::url('civicrm/contact/view/rel', "action=view&reset=1&id={$viewRelationship[$this->_id]['id']}&cid={$this->_contactId}&context=home");
     require_once 'CRM/Core/Session.php';
     require_once 'CRM/Contact/BAO/Contact/Permission.php';
     $session = CRM_Core_Session::singleton();
     $recentOther = array();
     if ($session->get('userID') == $this->_contactId || CRM_Contact_BAO_Contact_Permission::allow($this->_contactId, CRM_Core_Permission::EDIT)) {
         $recentOther = array('editUrl' => CRM_Utils_System::url('civicrm/contact/view/rel', "action=update&reset=1&id={$viewRelationship[$this->_id]['id']}&cid={$this->_contactId}&rtype={$rType}&context=home"), 'deleteUrl' => CRM_Utils_System::url('civicrm/contact/view/rel', "action=delete&reset=1&id={$viewRelationship[$this->_id]['id']}&cid={$this->_contactId}&rtype={$rType}&context=home"));
     }
     $displayName = CRM_Contact_BAO_Contact::displayName($this->_contactId);
     $this->assign('displayName', $displayName);
     $title = $displayName . ' (' . $viewRelationship[$this->_id]['relation'] . ' ' . CRM_Contact_BAO_Contact::displayName($viewRelationship[$this->_id]['cid']) . ')';
     // add the recently viewed Relationship
     CRM_Utils_Recent::add($title, $url, $viewRelationship[$this->_id]['id'], 'Relationship', $this->_contactId, null, $recentOther);
 }

 /**
  * Function to add/copy relationships, when new client is added for a case
  *
  * @param int $caseId case id
  * @param int $contactId contact id / new client id
  *
  * @return void
  */
 static function addCaseRelationships($caseId, $contactId)
 {
     // get the case role / relationships for the case
     $caseRelationships = new CRM_Contact_DAO_Relationship();
     $caseRelationships->case_id = $caseId;
     $caseRelationships->find();
     $relationshipTypes = array();
     // make sure we don't add duplicate relationships of same relationship type.
     while ($caseRelationships->fetch() && !in_array($caseRelationships->relationship_type_id, $relationshipTypes)) {
         $values = array();
         CRM_Core_DAO::storeValues($caseRelationships, $values);
         // add relationship for new client.
         $newRelationship = new CRM_Contact_DAO_Relationship();
         $newRelationship->copyValues($values);
         $newRelationship->id = NULL;
         $newRelationship->case_id = $caseId;
         $newRelationship->contact_id_a = $contactId;
         $newRelationship->end_date = CRM_Utils_Date::isoToMysql($caseRelationships->end_date);
         $newRelationship->start_date = CRM_Utils_Date::isoToMysql($caseRelationships->start_date);
         // another check to avoid duplicate relationship, in cases where client is removed and re-added again.
         if (!$newRelationship->find(TRUE)) {
             $newRelationship->save();
         }
         $newRelationship->free();
         // store relationship type of newly created relationship
         $relationshipTypes[] = $caseRelationships->relationship_type_id;
     }
 }

 /**                                                           
  * Function to get individual id for onbehalf contribution
  * @param  int   $contributionId  contribution id 
  * @param  int   $contributorId   contributer id
  * @return array $ids             containing organization id and individual id
  * @access public 
  */
 function getOnbehalfIds($contributionId, $contributorId = null)
 {
     $ids = array();
     if (!$contributionId) {
         return $ids;
     }
     // fetch contributor id if null
     if (!$contributorId) {
         require_once 'CRM/Core/DAO.php';
         $contributorId = CRM_Core_DAO::getFieldValue('CRM_Contribute_DAO_Contribution', $contributionId, 'contact_id');
     }
     require_once 'CRM/Core/PseudoConstant.php';
     $activityTypeIds = CRM_Core_PseudoConstant::activityType(true, false, false, 'name');
     $activityTypeId = array_search("Contribution", $activityTypeIds);
     if ($activityTypeId && $contributorId) {
         $activityQuery = "\nSELECT source_contact_id \n  FROM civicrm_activity \n WHERE activity_type_id   = %1 \n   AND source_record_id   = %2";
         $params = array(1 => array($activityTypeId, 'Integer'), 2 => array($contributionId, 'Integer'));
         $sourceContactId = CRM_Core_DAO::singleValueQuery($activityQuery, $params);
         // for on behalf contribution source is individual and contributor is organization
         if ($sourceContactId && $sourceContactId != $contributorId) {
             $relationshipTypeIds = CRM_Core_PseudoConstant::relationshipType('name');
             // get rel type id for employee of relation
             foreach ($relationshipTypeIds as $id => $typeVals) {
                 if ($typeVals['name_a_b'] == 'Employee of') {
                     $relationshipTypeId = $id;
                     break;
                 }
             }
             require_once 'CRM/Contact/DAO/Relationship.php';
             $rel = new CRM_Contact_DAO_Relationship();
             $rel->relationship_type_id = $relationshipTypeId;
             $rel->contact_id_a = $sourceContactId;
             $rel->contact_id_b = $contributorId;
             if ($rel->find(true)) {
                 $ids['individual_id'] = $rel->contact_id_a;
                 $ids['organization_id'] = $rel->contact_id_b;
             }
         }
     }
     return $ids;
 }

 public static function relationship()
 {
     $relType = CRM_Utils_Request::retrieve('rel_type', 'Positive', CRM_Core_DAO::$_nullObject, TRUE);
     $relContactID = CRM_Utils_Request::retrieve('rel_contact', 'Positive', CRM_Core_DAO::$_nullObject, TRUE);
     $relationshipID = CRM_Utils_Request::retrieve('rel_id', 'Positive', CRM_Core_DAO::$_nullObject);
     // this used only to determine add or update mode
     $caseID = CRM_Utils_Request::retrieve('case_id', 'Positive', CRM_Core_DAO::$_nullObject, TRUE);
     // check if there are multiple clients for this case, if so then we need create
     // relationship and also activities for each contacts
     // get case client list
     $clientList = CRM_Case_BAO_Case::getCaseClients($caseID);
     $ret = array('is_error' => 0);
     foreach ($clientList as $sourceContactID) {
         $relationParams = array('relationship_type_id' => $relType . '_a_b', 'contact_check' => array($relContactID => 1), 'is_active' => 1, 'case_id' => $caseID, 'start_date' => date("Ymd"));
         $relationIds = array('contact' => $sourceContactID);
         // check if we are editing/updating existing relationship
         if ($relationshipID && $relationshipID != 'null') {
             // here we need to retrieve appropriate relationshipID based on client id and relationship type id
             $caseRelationships = new CRM_Contact_DAO_Relationship();
             $caseRelationships->case_id = $caseID;
             $caseRelationships->relationship_type_id = $relType;
             $caseRelationships->contact_id_a = $sourceContactID;
             $caseRelationships->find();
             while ($caseRelationships->fetch()) {
                 $relationIds['relationship'] = $caseRelationships->id;
                 $relationIds['contactTarget'] = $relContactID;
             }
             $caseRelationships->free();
         }
         // create new or update existing relationship
         $return = CRM_Contact_BAO_Relationship::legacyCreateMultiple($relationParams, $relationIds);
         if (!empty($return[4][0])) {
             $relationshipID = $return[4][0];
             //create an activity for case role assignment.CRM-4480
             CRM_Case_BAO_Case::createCaseRoleActivity($caseID, $relationshipID, $relContactID);
         } else {
             $ret = array('is_error' => 1, 'error_message' => ts('The relationship type definition for the case role is not valid for the client and / or staff contact types. You can review and edit relationship types at <a href="%1">Administer >> Option Lists >> Relationship Types</a>.', array(1 => CRM_Utils_System::url('civicrm/admin/reltype', 'reset=1'))));
         }
     }
     CRM_Utils_JSON::output($ret);
 }

 /**
  * Get individual id for onbehalf contribution.
  *
  * @param int $contributionId
  *   Contribution id.
  * @param int $contributorId
  *   Contributor id.
  *
  * @return array
  *   containing organization id and individual id
  */
 public static function getOnbehalfIds($contributionId, $contributorId = NULL)
 {
     $ids = array();
     if (!$contributionId) {
         return $ids;
     }
     // fetch contributor id if null
     if (!$contributorId) {
         $contributorId = CRM_Core_DAO::getFieldValue('CRM_Contribute_DAO_Contribution', $contributionId, 'contact_id');
     }
     $activityTypeIds = CRM_Core_PseudoConstant::activityType(TRUE, FALSE, FALSE, 'name');
     $activityTypeId = array_search('Contribution', $activityTypeIds);
     if ($activityTypeId && $contributorId) {
         $activityQuery = "\nSELECT     civicrm_activity_contact.contact_id\n  FROM     civicrm_activity_contact\nINNER JOIN civicrm_activity ON civicrm_activity_contact.activity_id = civicrm_activity.id\n WHERE     civicrm_activity.activity_type_id   = %1\n   AND     civicrm_activity.source_record_id   = %2\n   AND     civicrm_activity_contact.record_type_id = %3\n";
         $activityContacts = CRM_Core_OptionGroup::values('activity_contacts', FALSE, FALSE, FALSE, NULL, 'name');
         $sourceID = CRM_Utils_Array::key('Activity Source', $activityContacts);
         $params = array(1 => array($activityTypeId, 'Integer'), 2 => array($contributionId, 'Integer'), 3 => array($sourceID, 'Integer'));
         $sourceContactId = CRM_Core_DAO::singleValueQuery($activityQuery, $params);
         // for on behalf contribution source is individual and contributor is organization
         if ($sourceContactId && $sourceContactId != $contributorId) {
             $relationshipTypeIds = CRM_Core_PseudoConstant::relationshipType('name');
             // get rel type id for employee of relation
             foreach ($relationshipTypeIds as $id => $typeVals) {
                 if ($typeVals['name_a_b'] == 'Employee of') {
                     $relationshipTypeId = $id;
                     break;
                 }
             }
             $rel = new CRM_Contact_DAO_Relationship();
             $rel->relationship_type_id = $relationshipTypeId;
             $rel->contact_id_a = $sourceContactId;
             $rel->contact_id_b = $contributorId;
             if ($rel->find(TRUE)) {
                 $ids['individual_id'] = $rel->contact_id_a;
                 $ids['organization_id'] = $rel->contact_id_b;
             }
         }
     }
     return $ids;
 }

 /**
  * Get the other contact in a relationship.
  *
  * @param int $id
  *   Relationship id.
  *
  * $returns  returns the contact ids in the realtionship
  *
  * @return \CRM_Contact_DAO_Relationship
  */
 public static function getRelationshipByID($id)
 {
     $relationship = new CRM_Contact_DAO_Relationship();
     $relationship->id = $id;
     $relationship->selectAdd();
     $relationship->selectAdd('contact_id_a, contact_id_b');
     $relationship->find(TRUE);
     return $relationship;
 }

 /**
  * Clear cached current employer name.
  *
  * @param int $contactId
  *   Contact id ( mostly individual contact id).
  * @param int $employerId
  *   Contact id ( mostly organization contact id).
  */
 public static function clearCurrentEmployer($contactId, $employerId = NULL)
 {
     $query = "UPDATE civicrm_contact\nSET organization_name=NULL, employer_id = NULL\nWHERE id={$contactId}; ";
     $dao = CRM_Core_DAO::executeQuery($query);
     // need to handle related meberships. CRM-3792
     if ($employerId) {
         //1. disable corresponding relationship.
         //2. delete related membership.
         //get the relationship type id of "Employee of"
         $relTypeId = CRM_Core_DAO::getFieldValue('CRM_Contact_DAO_RelationshipType', 'Employee of', 'id', 'name_a_b');
         if (!$relTypeId) {
             CRM_Core_Error::fatal(ts("You seem to have deleted the relationship type 'Employee of'"));
         }
         $relMembershipParams['relationship_type_id'] = $relTypeId . '_a_b';
         $relMembershipParams['contact_check'][$employerId] = 1;
         //get relationship id.
         if (CRM_Contact_BAO_Relationship::checkDuplicateRelationship($relMembershipParams, $contactId, $employerId)) {
             $relationship = new CRM_Contact_DAO_Relationship();
             $relationship->contact_id_a = $contactId;
             $relationship->contact_id_b = $employerId;
             $relationship->relationship_type_id = $relTypeId;
             if ($relationship->find(TRUE)) {
                 CRM_Contact_BAO_Relationship::setIsActive($relationship->id, FALSE);
                 CRM_Contact_BAO_Relationship::relatedMemberships($contactId, $relMembershipParams, $ids = array(), CRM_Core_Action::DELETE);
             }
             $relationship->free();
         }
     }
 }

 /**
  * @param array $params
  *
  * @return bool
  */
 public function createRelationship(&$params)
 {
     $dao = new CRM_Contact_DAO_Relationship();
     $dao->copyValues($params);
     // only create a relationship if it does not exist
     if (!$dao->find(TRUE)) {
         $dao->save();
     }
     return TRUE;
 }

 function mergeSameHousehold(&$rows)
 {
     # group selected contacts by type
     $individuals = array();
     $households = array();
     foreach ($rows as $contact_id => $row) {
         if ($row['contact_type'] == 'Household') {
             $households[$contact_id] = $row;
         } elseif ($row['contact_type'] == 'Individual') {
             $individuals[$contact_id] = $row;
         }
     }
     # exclude individuals belonging to selected households
     foreach ($households as $household_id => $row) {
         $dao = new CRM_Contact_DAO_Relationship();
         $dao->contact_id_b = $household_id;
         $dao->find();
         while ($dao->fetch()) {
             $individual_id = $dao->contact_id_a;
             if (array_key_exists($individual_id, $individuals)) {
                 unset($individuals[$individual_id]);
             }
         }
     }
     # merge back individuals and households
     $rows = array_merge($individuals, $households);
     return $rows;
 }

 static function relationship()
 {
     $relType = CRM_Utils_Array::value('rel_type', $_REQUEST);
     $relContactID = CRM_Utils_Array::value('rel_contact', $_REQUEST);
     $sourceContactID = CRM_Utils_Array::value('contact_id', $_REQUEST);
     // we no longer need this.
     $relationshipID = CRM_Utils_Array::value('rel_id', $_REQUEST);
     // this used only to determine add or update mode
     $caseID = CRM_Utils_Array::value('case_id', $_REQUEST);
     // check if there are multiple clients for this case, if so then we need create
     // relationship and also activities for each contacts
     // get case client list
     $clientList = CRM_Case_BAO_Case::getCaseClients($caseID);
     foreach ($clientList as $sourceContactID) {
         $relationParams = array('relationship_type_id' => $relType . '_a_b', 'contact_check' => array($relContactID => 1), 'is_active' => 1, 'case_id' => $caseID, 'start_date' => date("Ymd"));
         $relationIds = array('contact' => $sourceContactID);
         // check if we are editing/updating existing relationship
         if ($relationshipID && $relationshipID != 'null') {
             // here we need to retrieve appropriate relationshipID based on client id and relationship type id
             $caseRelationships = new CRM_Contact_DAO_Relationship();
             $caseRelationships->case_id = $caseID;
             $caseRelationships->relationship_type_id = $relType;
             $caseRelationships->contact_id_a = $sourceContactID;
             $caseRelationships->find();
             while ($caseRelationships->fetch()) {
                 $relationIds['relationship'] = $caseRelationships->id;
                 $relationIds['contactTarget'] = $relContactID;
             }
             $caseRelationships->free();
         }
         // create new or update existing relationship
         $return = CRM_Contact_BAO_Relationship::create($relationParams, $relationIds);
         $status = 'process-relationship-fail';
         if (CRM_Utils_Array::value(0, $return[4])) {
             $relationshipID = $return[4][0];
             $status = 'process-relationship-success';
             //create an activity for case role assignment.CRM-4480
             CRM_Case_BAO_Case::createCaseRoleActivity($caseID, $relationshipID, $relContactID);
         }
     }
     $relation['status'] = $status;
     echo json_encode($relation);
     CRM_Utils_System::civiExit();
 }

    /**
     * Function perform two task.
     * 1. Merge two duplicate contacts cases - follow CRM-5758 rules.
     * 2. Merge two cases of same contact - follow CRM-5598 rules.
     *
     * @param int $mainContactId    contact id of main contact record.
     * @param int $mainCaseId       case id of main case record.
     * @param int $otherContactId   contact id of record which is going to merge.
     * @param int $otherCaseId      case id of record which is going to merge.
     *
     * @return void.
     * @static
     */
    function mergeCases($mainContactId, $mainCaseId = NULL, $otherContactId = NULL, $otherCaseId = NULL, $changeClient = FALSE)
    {
        $moveToTrash = TRUE;
        $duplicateContacts = FALSE;
        if ($mainContactId && $otherContactId && $mainContactId != $otherContactId) {
            $duplicateContacts = TRUE;
        }
        $duplicateCases = FALSE;
        if ($mainCaseId && $otherCaseId && $mainCaseId != $otherCaseId) {
            $duplicateCases = TRUE;
        }
        $mainCaseIds = array();
        if (!$duplicateContacts && !$duplicateCases) {
            return $mainCaseIds;
        }
        $activityTypes = CRM_Core_PseudoConstant::activityType(TRUE, TRUE, FALSE, 'name');
        $activityStatuses = CRM_Core_PseudoConstant::activityStatus('name');
        $processCaseIds = array($otherCaseId);
        if ($duplicateContacts && !$duplicateCases) {
            if ($changeClient) {
                $processCaseIds = array($mainCaseId);
            } else {
                //get all case ids for other contact.
                $processCaseIds = self::retrieveCaseIdsByContactId($otherContactId, TRUE);
            }
            if (!is_array($processCaseIds)) {
                return;
            }
        }
        $session = CRM_Core_Session::singleton();
        $currentUserId = $session->get('userID');
        // copy all cases and connect to main contact id.
        foreach ($processCaseIds as $otherCaseId) {
            if ($duplicateContacts) {
                $mainCase = CRM_Core_DAO::copyGeneric('CRM_Case_DAO_Case', array('id' => $otherCaseId));
                $mainCaseId = $mainCase->id;
                if (!$mainCaseId) {
                    continue;
                }
                $mainCase->free();
                $mainCaseIds[] = $mainCaseId;
                //insert record for case contact.
                $otherCaseContact = new CRM_Case_DAO_CaseContact();
                $otherCaseContact->case_id = $otherCaseId;
                $otherCaseContact->find();
                while ($otherCaseContact->fetch()) {
                    $mainCaseContact = new CRM_Case_DAO_CaseContact();
                    $mainCaseContact->case_id = $mainCaseId;
                    $mainCaseContact->contact_id = $otherCaseContact->contact_id;
                    if ($mainCaseContact->contact_id == $otherContactId) {
                        $mainCaseContact->contact_id = $mainContactId;
                    }
                    //avoid duplicate object.
                    if (!$mainCaseContact->find(TRUE)) {
                        $mainCaseContact->save();
                    }
                    $mainCaseContact->free();
                }
                $otherCaseContact->free();
            } elseif (!$otherContactId) {
                $otherContactId = $mainContactId;
            }
            if (!$mainCaseId || !$otherCaseId || !$mainContactId || !$otherContactId) {
                continue;
            }
            // get all activities for other case.
            $otherCaseActivities = array();
            CRM_Core_DAO::commonRetrieveAll('CRM_Case_DAO_CaseActivity', 'case_id', $otherCaseId, $otherCaseActivities);
            //for duplicate cases do not process singleton activities.
            $otherActivityIds = $singletonActivityIds = array();
            foreach ($otherCaseActivities as $caseActivityId => $otherIds) {
                $otherActId = CRM_Utils_Array::value('activity_id', $otherIds);
                if (!$otherActId || in_array($otherActId, $otherActivityIds)) {
                    continue;
                }
                $otherActivityIds[] = $otherActId;
            }
            if ($duplicateCases) {
                if ($openCaseType = array_search('Open Case', $activityTypes)) {
                    $sql = "\nSELECT  id\n  FROM  civicrm_activity \n WHERE  activity_type_id = {$openCaseType} \n   AND  id IN ( " . implode(',', array_values($otherActivityIds)) . ');';
                    $dao = CRM_Core_DAO::executeQuery($sql);
                    while ($dao->fetch()) {
                        $singletonActivityIds[] = $dao->id;
                    }
                    $dao->free();
                }
            }
//.........这里部分代码省略.........

 /**
  * Function to get the other contact in a relationship
  *
  * @param int $id relationship id
  *
  * $returns  returns the contact ids in the realtionship
  * @access public
  * @static
  */
 static function getContactIds($id)
 {
     $relationship = new CRM_Contact_DAO_Relationship();
     $relationship->id = $id;
     $relationship->selectAdd();
     $relationship->selectAdd('contact_id_a, contact_id_b');
     $relationship->find(true);
     return $relationship;
 }

 function createRelationship(&$params)
 {
     require_once 'CRM/Contact/DAO/Relationship.php';
     $dao = new CRM_Contact_DAO_Relationship();
     $dao->copyValues($params);
     // only create a relationship if it does not exist
     if (!$dao->find(true)) {
         $dao->save();
     }
     return true;
 }