/**
  * 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);
 }

 /**
  * Get a list of relationships.
  *
  * @param int $contactId
  *   Contact id.
  * @param int $status
  *   1: Past 2: Disabled 3: Current.
  * @param int $numRelationship
  *   No of relationships to display (limit).
  * @param int $count
  *   Get the no of relationships.
  * @param int $relationshipId
  * @param array $links
  *   the list of links to display
  * @param int $permissionMask
  *   the permission mask to be applied for the actions
  * @param bool $permissionedContact
  *   to return only permissioned Contact
  * @param array $params
  *
  * @return array|int
  *   relationship records
  */
 public static function getRelationship($contactId = NULL, $status = 0, $numRelationship = 0, $count = 0, $relationshipId = 0, $links = NULL, $permissionMask = NULL, $permissionedContact = FALSE, $params = array())
 {
     $values = array();
     if (!$contactId && !$relationshipId) {
         return $values;
     }
     list($select1, $from1, $where1) = self::makeURLClause($contactId, $status, $numRelationship, $count, $relationshipId, 'a_b', $params);
     list($select2, $from2, $where2) = self::makeURLClause($contactId, $status, $numRelationship, $count, $relationshipId, 'b_a', $params);
     $order = $limit = '';
     if (!$count) {
         if (empty($params['sort'])) {
             $order = ' ORDER BY civicrm_relationship_type_id, sort_name ';
         } else {
             $order = " ORDER BY {$params['sort']} ";
         }
         $offset = 0;
         if (!empty($params['offset']) && $params['offset'] > 0) {
             $offset = $params['offset'];
         }
         if ($numRelationship) {
             $limit = " LIMIT {$offset}, {$numRelationship}";
         }
     }
     // building the query string
     $queryString = $select1 . $from1 . $where1 . $select2 . $from2 . $where2 . $order . $limit;
     $relationship = new CRM_Contact_DAO_Relationship();
     $relationship->query($queryString);
     $row = array();
     if ($count) {
         $relationshipCount = 0;
         while ($relationship->fetch()) {
             $relationshipCount += $relationship->cnt1 + $relationship->cnt2;
         }
         return $relationshipCount;
     } else {
         $mask = NULL;
         if ($status != self::INACTIVE) {
             if ($links) {
                 $mask = array_sum(array_keys($links));
                 if ($mask & CRM_Core_Action::DISABLE) {
                     $mask -= CRM_Core_Action::DISABLE;
                 }
                 if ($mask & CRM_Core_Action::ENABLE) {
                     $mask -= CRM_Core_Action::ENABLE;
                 }
                 if ($status == self::CURRENT) {
                     $mask |= CRM_Core_Action::DISABLE;
                 } elseif ($status == self::DISABLED) {
                     $mask |= CRM_Core_Action::ENABLE;
                 }
                 $mask = $mask & $permissionMask;
             }
         }
         while ($relationship->fetch()) {
             $rid = $relationship->civicrm_relationship_id;
             $cid = $relationship->civicrm_contact_id;
             if ($permissionedContact && !CRM_Contact_BAO_Contact_Permission::allow($cid)) {
                 continue;
             }
             $values[$rid]['id'] = $rid;
             $values[$rid]['cid'] = $cid;
             $values[$rid]['contact_id_a'] = $relationship->contact_id_a;
             $values[$rid]['contact_id_b'] = $relationship->contact_id_b;
             $values[$rid]['contact_type'] = $relationship->contact_type;
             $values[$rid]['relationship_type_id'] = $relationship->civicrm_relationship_type_id;
             $values[$rid]['relation'] = $relationship->relation;
             $values[$rid]['name'] = $relationship->sort_name;
             $values[$rid]['display_name'] = $relationship->display_name;
             $values[$rid]['job_title'] = $relationship->job_title;
             $values[$rid]['email'] = $relationship->email;
             $values[$rid]['phone'] = $relationship->phone;
             $values[$rid]['employer_id'] = $relationship->employer_id;
             $values[$rid]['organization_name'] = $relationship->organization_name;
             $values[$rid]['country'] = $relationship->country;
             $values[$rid]['city'] = $relationship->city;
             $values[$rid]['state'] = $relationship->state;
             $values[$rid]['start_date'] = $relationship->start_date;
//.........这里部分代码省略.........

 /**
  * 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();
         }
     }
 }

 /**
  * Delete Relationship Types.
  *
  * @param int $relationshipTypeId
  *
  * @throws CRM_Core_Exception
  * @return mixed
  */
 public static function del($relationshipTypeId)
 {
     // make sure relationshipTypeId is an integer
     // @todo review this as most delete functions rely on the api & form layer for this
     // or do a find first & throw error if no find
     if (!CRM_Utils_Rule::positiveInteger($relationshipTypeId)) {
         throw new CRM_Core_Exception(ts('Invalid relationship type'));
     }
     //check dependencies
     // delete all relationships
     $relationship = new CRM_Contact_DAO_Relationship();
     $relationship->relationship_type_id = $relationshipTypeId;
     $relationship->delete();
     // remove this relationship type from membership types
     $mems = civicrm_api3('MembershipType', 'get', array('relationship_type_id' => array('LIKE' => "%{$relationshipTypeId}%"), 'return' => array('id', 'relationship_type_id', 'relationship_direction')));
     foreach ($mems['values'] as $membershipTypeId => $membershipType) {
         $pos = array_search($relationshipTypeId, $membershipType['relationship_type_id']);
         // Api call may have returned false positives but currently the relationship_type_id uses
         // nonstandard serialization which makes anything more accurate impossible.
         if ($pos !== FALSE) {
             unset($membershipType['relationship_type_id'][$pos], $membershipType['relationship_direction'][$pos]);
             civicrm_api3('MembershipType', 'create', $membershipType);
         }
     }
     //fixed for CRM-3323
     $mappingField = new CRM_Core_DAO_MappingField();
     $mappingField->relationship_type_id = $relationshipTypeId;
     $mappingField->find();
     while ($mappingField->fetch()) {
         $mappingField->delete();
     }
     $relationshipType = new CRM_Contact_DAO_RelationshipType();
     $relationshipType->id = $relationshipTypeId;
     return $relationshipType->delete();
 }

 /**
  * Function to delete Relationship Types
  *
  * @param int $relationshipTypeId
  * @static
  */
 static function del($relationshipTypeId)
 {
     // make sure relationshipTypeId is an integer
     // @todo review this as most delete functions rely on the api & form layer for this
     // or do a find first & throw error if no find
     if (!CRM_Utils_Rule::positiveInteger($relationshipTypeId)) {
         throw new CRM_Core_Exception(ts('Invalid relationship type'));
     }
     //check dependencies
     // delete all relationships
     $relationship = new CRM_Contact_DAO_Relationship();
     $relationship->relationship_type_id = $relationshipTypeId;
     $relationship->delete();
     // set all membership_type to null
     $query = "\nUPDATE civicrm_membership_type\n  SET  relationship_type_id = NULL\n WHERE relationship_type_id = %1\n";
     $params = array(1 => array(CRM_Core_DAO::VALUE_SEPARATOR . $relationshipTypeId . CRM_Core_DAO::VALUE_SEPARATOR, 'String'));
     CRM_Core_DAO::executeQuery($query, $params);
     //fixed for CRM-3323
     $mappingField = new CRM_Core_DAO_MappingField();
     $mappingField->relationship_type_id = $relationshipTypeId;
     $mappingField->find();
     while ($mappingField->fetch()) {
         $mappingField->delete();
     }
     $relationshipType = new CRM_Contact_DAO_RelationshipType();
     $relationshipType->id = $relationshipTypeId;
     return $relationshipType->delete();
 }

 /**
  * @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 to delete Relationship Types
  *
  * @param int $relationshipTypeId
  * @static
  */
 static function del($relationshipTypeId)
 {
     // make sure relationshipTypeId is an integer
     if (!CRM_Utils_Rule::positiveInteger($relationshipTypeId)) {
         CRM_Core_Error::fatal(ts('Invalid relationship type'));
     }
     //check dependencies
     // delete all relationships
     $relationship = new CRM_Contact_DAO_Relationship();
     $relationship->relationship_type_id = $relationshipTypeId;
     $relationship->delete();
     // set all membership_type to null
     $query = "\nUPDATE civicrm_membership_type\n  SET  relationship_type_id = NULL\n WHERE relationship_type_id = %1\n";
     $params = array(1 => array($relationshipTypeId, 'Integer'));
     CRM_Core_DAO::executeQuery($query, $params);
     //fixed for CRM-3323
     $mappingField = new CRM_Core_DAO_MappingField();
     $mappingField->relationship_type_id = $relationshipTypeId;
     $mappingField->find();
     while ($mappingField->fetch()) {
         $mappingField->delete();
     }
     $relationshipType = new CRM_Contact_DAO_RelationshipType();
     $relationshipType->id = $relationshipTypeId;
     return $relationshipType->delete();
 }

 /**                                                           
  * 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;
 }

/**
 * take the input parameter list as specified in the data model and
 * convert it into the same format that we use in QF and BAO object
 *
 * @param array  $params       Associative array of property name/value
 *                             pairs to insert in new contact.
 * @param array  $values       The reformatted properties that we can use internally
 *                            '
 *
 * @return array|CRM_Error
 * @access public
 */
function _civicrm_relationship_format_params(&$params, &$values)
{
    // copy all the relationship fields as is
    $fields = CRM_Contact_DAO_Relationship::fields();
    _civicrm_store_values($fields, $params, $values);
    $relationTypes = CRM_Core_PseudoConstant::relationshipType('name', TRUE);
    foreach ($params as $key => $value) {
        // ignore empty values or empty arrays etc
        require_once 'CRM/Utils/System.php';
        if (CRM_Utils_System::isNull($value)) {
            continue;
        }
        switch ($key) {
            case 'contact_id_a':
            case 'contact_id_b':
                require_once 'CRM/Utils/Rule.php';
                if (!CRM_Utils_Rule::integer($value)) {
                    return civicrm_create_error("contact_id not valid: {$value}");
                }
                $dao = new CRM_Core_DAO();
                $qParams = array();
                $svq = $dao->singleValueQuery("SELECT id FROM civicrm_contact WHERE id = {$value}", $qParams);
                if (!$svq) {
                    return civicrm_create_error("Invalid Contact ID: There is no contact record with contact_id = {$value}.");
                }
                break;
            case 'start_date':
            case 'end_date':
                if (!CRM_Utils_Rule::qfDate($value)) {
                    return civicrm_create_error("{$key} not a valid date: {$value}");
                }
                break;
            case 'relationship_type':
                foreach ($relationTypes as $relTypId => $relValue) {
                    if (CRM_Utils_Array::key(ucfirst($value), $relValue)) {
                        $relationshipTypeId = $relTypId;
                        break;
                    }
                }
                if ($relationshipTypeId) {
                    if (CRM_Utils_Array::value('relationship_type_id', $values) && $relationshipTypeId != $values['relationship_type_id']) {
                        return civicrm_create_error('Mismatched Relationship Type and Relationship Type Id');
                    }
                    $values['relationship_type_id'] = $params['relationship_type_id'] = $relationshipTypeId;
                } else {
                    return civicrm_create_error('Invalid Relationship Type');
                }
            case 'relationship_type_id':
                if ($key == 'relationship_type_id' && !array_key_exists($value, $relationTypes)) {
                    return civicrm_create_error("{$key} not a valid: {$value}");
                }
                // execute for both relationship_type and relationship_type_id
                $relation = $relationTypes[$params['relationship_type_id']];
                require_once 'CRM/Contact/BAO/Contact.php';
                if ($relation['contact_type_a'] && $relation['contact_type_a'] != CRM_Contact_BAO_Contact::getContactType($params['contact_id_a'])) {
                    return civicrm_create_error("Contact ID :{$params['contact_id_a']} is not of contact type {$relation['contact_type_a']}");
                }
                if ($relation['contact_type_b'] && $relation['contact_type_b'] != CRM_Contact_BAO_Contact::getContactType($params['contact_id_b'])) {
                    return civicrm_create_error("Contact ID :{$params['contact_id_b']} is not of contact type {$relation['contact_type_b']}");
                }
                break;
            default:
                break;
        }
    }
    if (array_key_exists('note', $params)) {
        $values['note'] = $params['note'];
    }
    _civicrm_custom_format_params($params, $values, 'Relationship');
    return array();
}

 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();
 }

//.........这里部分代码省略.........
                    $mainActivityTarget->target_contact_id = $otherTargetActivity->target_contact_id;
                    if ($mainActivityTarget->target_contact_id == $otherContactId) {
                        $mainActivityTarget->target_contact_id = $mainContactId;
                    }
                    //avoid duplicate object.
                    if (!$mainActivityTarget->find(TRUE)) {
                        $mainActivityTarget->save();
                    }
                    $mainActivityTarget->free();
                }
                $otherTargetActivity->free();
                //migrate assignee activities.
                $otherAssigneeActivity = new CRM_Activity_DAO_ActivityAssignment();
                $otherAssigneeActivity->activity_id = $otherActivityId;
                $otherAssigneeActivity->find();
                while ($otherAssigneeActivity->fetch()) {
                    $mainAssigneeActivity = new CRM_Activity_DAO_ActivityAssignment();
                    $mainAssigneeActivity->activity_id = $mainActivityId;
                    $mainAssigneeActivity->assignee_contact_id = $otherAssigneeActivity->assignee_contact_id;
                    if ($mainAssigneeActivity->assignee_contact_id == $otherContactId) {
                        $mainAssigneeActivity->assignee_contact_id = $mainContactId;
                    }
                    //avoid duplicate object.
                    if (!$mainAssigneeActivity->find(TRUE)) {
                        $mainAssigneeActivity->save();
                    }
                    $mainAssigneeActivity->free();
                }
                $otherAssigneeActivity->free();
            }
            //copy case relationship.
            if ($duplicateContacts) {
                //migrate relationship records.
                $otherRelationship = new CRM_Contact_DAO_Relationship();
                $otherRelationship->case_id = $otherCaseId;
                $otherRelationship->find();
                $otherRelationshipIds = array();
                while ($otherRelationship->fetch()) {
                    $otherRelVals = array();
                    $updateOtherRel = FALSE;
                    CRM_Core_DAO::storeValues($otherRelationship, $otherRelVals);
                    $mainRelationship = new CRM_Contact_DAO_Relationship();
                    $mainRelationship->copyValues($otherRelVals);
                    $mainRelationship->id = NULL;
                    $mainRelationship->case_id = $mainCaseId;
                    if ($mainRelationship->contact_id_a == $otherContactId) {
                        $updateOtherRel = TRUE;
                        $mainRelationship->contact_id_a = $mainContactId;
                    }
                    //case creator change only when we merge user contact.
                    if ($mainRelationship->contact_id_b == $otherContactId) {
                        //do not change creator for change client.
                        if (!$changeClient) {
                            $updateOtherRel = TRUE;
                            $mainRelationship->contact_id_b = $currentUserId ? $currentUserId : $mainContactId;
                        }
                    }
                    $mainRelationship->end_date = CRM_Utils_Date::isoToMysql($otherRelationship->end_date);
                    $mainRelationship->start_date = CRM_Utils_Date::isoToMysql($otherRelationship->start_date);
                    //avoid duplicate object.
                    if (!$mainRelationship->find(TRUE)) {
                        $mainRelationship->save();
                    }
                    $mainRelationship->free();
                    //get the other relationship ids to update end date.
                    if ($updateOtherRel) {

 /**
  * returns the list of fields that can be exported
  *
  * @access public
  * return array
  */
 function &export($prefix = false)
 {
     if (!$GLOBALS['_CRM_CONTACT_DAO_RELATIONSHIP']['_export']) {
         $GLOBALS['_CRM_CONTACT_DAO_RELATIONSHIP']['_export'] = array();
         $fields =& CRM_Contact_DAO_Relationship::fields();
         foreach ($fields as $name => $field) {
             if (CRM_Utils_Array::value('export', $field)) {
                 if ($prefix) {
                     $GLOBALS['_CRM_CONTACT_DAO_RELATIONSHIP']['_export']['relationship'] =& $fields[$name];
                 } else {
                     $GLOBALS['_CRM_CONTACT_DAO_RELATIONSHIP']['_export'][$name] =& $fields[$name];
                 }
             }
         }
     }
     return $GLOBALS['_CRM_CONTACT_DAO_RELATIONSHIP']['_export'];
 }

 /**
  * 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;
 }

 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;
 }

 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);
 }

/**
 * take the input parameter list as specified in the data model and
 * convert it into the same format that we use in QF and BAO object
 *
 * @param array $params Associative array of property name/value
 *                             pairs to insert in new contact.
 * @param array $values The reformatted properties that we can use internally
 *                            '
 *
 * @throws Exception
 * @return array|CRM_Error
 * @access public
 */
function _civicrm_api3_relationship_format_params($params, &$values)
{
    // copy all the relationship fields as is
    $fields = CRM_Contact_DAO_Relationship::fields();
    _civicrm_api3_store_values($fields, $params, $values);
    $relationTypes = CRM_Core_PseudoConstant::relationshipType('name');
    if (!empty($params['id'])) {
        $relation = new CRM_Contact_BAO_Relationship();
        $relation->id = $params['id'];
        if (!$relation->find(TRUE)) {
            throw new Exception('Relationship id is not valid');
        } else {
            if (isset($params['contact_id_a']) && $params['contact_id_a'] != $relation->contact_id_a || isset($params['contact_id_b']) && $params['contact_id_b'] != $relation->contact_id_b) {
                throw new Exception('Cannot change the contacts once relationship has been created');
            } else {
                // since the BAO function is not std & won't accept just 'id' (aargh) let's
                // at least return our BAO here
                $values = array();
                _civicrm_api3_object_to_array($relation, $values);
                $values = array_merge($values, $params);
                // and we need to reformat our date fields....
                $dateFields = array('start_date', 'end_date');
                foreach ($dateFields as $dateField) {
                    $values[$dateField] = CRM_Utils_Date::processDate($values[$dateField]);
                }
            }
        }
    }
    foreach ($params as $key => $value) {
        // ignore empty values or empty arrays etc
        if (CRM_Utils_System::isNull($value)) {
            continue;
        }
        switch ($key) {
            case 'contact_id_a':
            case 'contact_id_b':
                if (!CRM_Utils_Rule::integer($value)) {
                    throw new Exception("contact_id not valid: {$value}");
                }
                $dao = new CRM_Core_DAO();
                $qParams = array();
                $svq = $dao->singleValueQuery("SELECT id FROM civicrm_contact WHERE id = {$value}", $qParams);
                if (!$svq) {
                    throw new Exception("Invalid Contact ID: There is no contact record with contact_id = {$value}.");
                }
                break;
            case 'relationship_type':
                foreach ($relationTypes as $relTypId => $relValue) {
                    if (CRM_Utils_Array::key(ucfirst($value), $relValue)) {
                        $relationshipTypeId = $relTypId;
                        break;
                    }
                }
                if ($relationshipTypeId) {
                    if (!empty($values['relationship_type_id']) && $relationshipTypeId != $values['relationship_type_id']) {
                        throw new Exception('Mismatched Relationship Type and Relationship Type Id');
                    }
                    $values['relationship_type_id'] = $params['relationship_type_id'] = $relationshipTypeId;
                } else {
                    throw new Exception('Invalid Relationship Type');
                }
            case 'relationship_type_id':
                if ($key == 'relationship_type_id' && !array_key_exists($value, $relationTypes)) {
                    throw new Exception("{$key} not a valid: {$value}");
                }
                // execute for both relationship_type and relationship_type_id
                $relation = $relationTypes[$params['relationship_type_id']];
                if (!empty($params['contact_id_a']) && $relation['contact_type_a'] && $relation['contact_type_a'] != CRM_Contact_BAO_Contact::getContactType($params['contact_id_a'])) {
                    throw new Exception("Contact ID :{$params['contact_id_a']} is not of contact type {$relation['contact_type_a']}");
                }
                if (!empty($params['contact_id_b']) && $relation['contact_type_b'] && $relation['contact_type_b'] != CRM_Contact_BAO_Contact::getContactType($params['contact_id_b'])) {
                    throw new Exception("Contact ID :{$params['contact_id_b']} is not of contact type {$relation['contact_type_b']}");
                }
                break;
            default:
                break;
        }
    }
    if (array_key_exists('note', $params)) {
        $values['note'] = $params['note'];
    }
    _civicrm_api3_custom_format_params($params, $values, 'Relationship');
    return array();
}

 /**
  * Function to add/copy relationships, when new client is added for a case
  *
  * @param int $caseId case id
  * @param int $contactId