/**
* @todo Move this to ContactFormat.php
* @deprecated
*/
function civicrm_contact_format_create(&$params)
{
_civicrm_initialize();
CRM_Core_DAO::freeResult();
// return error if we have no params
if (empty($params)) {
return civicrm_create_error('Input Parameters empty');
}
$error = _civicrm_required_formatted_contact($params);
if (civicrm_error($error)) {
return $error;
}
$error = _civicrm_validate_formatted_contact($params);
if (civicrm_error($error)) {
return $error;
}
//get the prefix id etc if exists
require_once 'CRM/Contact/BAO/Contact.php';
CRM_Contact_BAO_Contact::resolveDefaults($params, TRUE);
require_once 'CRM/Import/Parser.php';
if (CRM_Utils_Array::value('onDuplicate', $params) != CRM_Import_Parser::DUPLICATE_NOCHECK) {
CRM_Core_Error::reset();
$error = _civicrm_duplicate_formatted_contact($params);
if (civicrm_error($error)) {
return $error;
}
}
$contact = CRM_Contact_BAO_Contact::create($params, CRM_Utils_Array::value('fixAddress', $params));
_civicrm_object_to_array($contact, $contactArray);
return $contactArray;
}
/**
* handle the values in import mode
*
* @param int $onDuplicate the code for what action to take on duplicates
* @param array $values the array of values belonging to this line
*
* @return boolean the result of this processing
* @access public
*/
function import($onDuplicate, &$values, $doGeocodeAddress = false)
{
$config =& CRM_Core_Config::singleton();
$this->_unparsedStreetAddressContacts = array();
if (!$doGeocodeAddress) {
// CRM-5854, reset the geocode method to null to prevent geocoding
$config->geocodeMethod = null;
}
// first make sure this is a valid line
//$this->_updateWithId = false;
$response = $this->summary($values);
$statusFieldName = $this->_statusFieldName;
if ($response != CRM_Import_Parser::VALID) {
$importRecordParams = array($statusFieldName => 'INVALID', "{$statusFieldName}Msg" => "Invalid (Error Code: {$response})");
$this->updateImportRecord($values[count($values) - 1], $importRecordParams);
return $response;
}
$params =& $this->getActiveFieldParams();
$formatted = array('contact_type' => $this->_contactType);
static $contactFields = null;
if ($contactFields == null) {
require_once "CRM/Contact/DAO/Contact.php";
$contactFields =& CRM_Contact_DAO_Contact::import();
}
//check if external identifier exists in database
if (CRM_Utils_Array::value('external_identifier', $params) && (CRM_Utils_Array::value('id', $params) || in_array($onDuplicate, array(CRM_Import_Parser::DUPLICATE_SKIP, CRM_Import_Parser::DUPLICATE_NOCHECK)))) {
require_once "CRM/Contact/BAO/Contact.php";
if ($internalCid = CRM_Core_DAO::getFieldValue('CRM_Contact_DAO_Contact', $params['external_identifier'], 'id', 'external_identifier')) {
if ($internalCid != CRM_Utils_Array::value('id', $params)) {
$errorMessage = ts('External Identifier already exists in database.');
array_unshift($values, $errorMessage);
$importRecordParams = array($statusFieldName => 'ERROR', "{$statusFieldName}Msg" => $errorMessage);
$this->updateImportRecord($values[count($values) - 1], $importRecordParams);
return CRM_Import_Parser::ERROR;
}
}
}
if (!empty($this->_contactSubType)) {
$params['contact_sub_type'] = $this->_contactSubType;
}
if ($subType = CRM_Utils_Array::value('contact_sub_type', $params)) {
if (CRM_Contact_BAO_ContactType::isExtendsContactType($subType, $this->_contactType, false, 'label')) {
$subTypes = CRM_Contact_BAO_ContactType::subTypePairs($this->_contactType, false, null);
$params['contact_sub_type'] = array_search($subType, $subTypes);
} elseif (!CRM_Contact_BAO_ContactType::isExtendsContactType($subType, $this->_contactType)) {
$message = "Mismatched or Invalid Contact SubType.";
array_unshift($values, $message);
return CRM_Import_Parser::NO_MATCH;
}
}
//get contact id to format common data in update/fill mode,
//if external identifier is present, CRM-4423
if ($this->_updateWithId && !CRM_Utils_Array::value('id', $params) && CRM_Utils_Array::value('external_identifier', $params)) {
if ($cid = CRM_Core_DAO::getFieldValue('CRM_Contact_DAO_Contact', $params['external_identifier'], 'id', 'external_identifier')) {
$formatted['id'] = $cid;
}
}
//format common data, CRM-4062
$this->formatCommonData($params, $formatted, $contactFields);
$relationship = false;
$createNewContact = true;
// Support Match and Update Via Contact ID
if ($this->_updateWithId) {
$createNewContact = false;
if (!CRM_Utils_Array::value('id', $params) && CRM_Utils_Array::value('external_identifier', $params)) {
if ($cid) {
$params['id'] = $cid;
} else {
//update contact if dedupe found contact id, CRM-4148
$dedupeParams = $formatted;
//special case to check dedupe if external id present.
//if we send external id dedupe will stop.
unset($dedupeParams['external_identifier']);
$checkDedupe = _civicrm_duplicate_formatted_contact($dedupeParams);
if (civicrm_duplicate($checkDedupe)) {
$matchingContactIds = explode(',', $checkDedupe['error_message']['params'][0]);
if (count($matchingContactIds) == 1) {
$params['id'] = array_pop($matchingContactIds);
} else {
$message = "More than one matching contact found for given criteria.";
array_unshift($values, $message);
$this->_retCode = CRM_Import_Parser::NO_MATCH;
}
} else {
$createNewContact = true;
}
}
}
$error = _civicrm_duplicate_formatted_contact($formatted);
if (civicrm_duplicate($error)) {
$matchedIDs = explode(',', $error['error_message']['params'][0]);
if (count($matchedIDs) >= 1) {
$updateflag = true;
foreach ($matchedIDs as $contactId) {
if ($params['id'] == $contactId) {
$contactType = CRM_Core_DAO::getFieldValue('CRM_Contact_DAO_Contact', $params['id'], 'contact_type');
if ($formatted['contact_type'] == $contactType) {
//validation of subtype for update mode
//CRM-5125
$contactSubType = null;
if (CRM_Utils_Array::value('contact_sub_type', $params)) {
$contactSubType = CRM_Core_DAO::getFieldValue('CRM_Contact_DAO_Contact', $params['id'], 'contact_sub_type');
}
if (!empty($contactSubType) && (!CRM_Contact_BAO_ContactType::isAllowEdit($params['id'], $contactSubType) || $contactSubType != CRM_Utils_Array::value('contact_sub_type', $formatted))) {
$message = "Mismatched contact SubTypes :";
array_unshift($values, $message);
$updateflag = false;
$this->_retCode = CRM_Import_Parser::NO_MATCH;
} else {
$newContact = $this->createContact($formatted, $contactFields, $onDuplicate, $contactId, false);
$updateflag = false;
$this->_retCode = CRM_Import_Parser::VALID;
}
} else {
$message = "Mismatched contact Types :";
array_unshift($values, $message);
$updateflag = false;
$this->_retCode = CRM_Import_Parser::NO_MATCH;
}
}
}
if ($updateflag) {
$message = "Mismatched contact IDs OR Mismatched contact Types :";
array_unshift($values, $message);
$this->_retCode = CRM_Import_Parser::NO_MATCH;
}
}
} else {
$contactType = null;
if (CRM_Utils_Array::value('id', $params)) {
$contactType = CRM_Core_DAO::getFieldValue('CRM_Contact_DAO_Contact', $params['id'], 'contact_type');
if ($contactType) {
if ($formatted['contact_type'] == $contactType) {
//validation of subtype for update mode
//CRM-5125
$contactSubType = null;
if (CRM_Utils_Array::value('contact_sub_type', $params)) {
$contactSubType = CRM_Core_DAO::getFieldValue('CRM_Contact_DAO_Contact', $params['id'], 'contact_sub_type');
}
if (!empty($contactSubType) && (!CRM_Contact_BAO_ContactType::isAllowEdit($params['id'], $contactSubType) || $contactSubType != CRM_Utils_Array::value('contact_sub_type', $formatted))) {
$message = "Mismatched contact SubTypes :";
array_unshift($values, $message);
$this->_retCode = CRM_Import_Parser::NO_MATCH;
} else {
$newContact = $this->createContact($formatted, $contactFields, $onDuplicate, $params['id'], false);
$this->_retCode = CRM_Import_Parser::VALID;
}
} else {
$message = "Mismatched contact Types :";
array_unshift($values, $message);
$this->_retCode = CRM_Import_Parser::NO_MATCH;
}
} else {
// we should avoid multiple errors for single record
// since we have already retCode and we trying to force again.
if ($this->_retCode != CRM_Import_Parser::NO_MATCH) {
$message = "No contact found for this contact ID:" . $params['id'];
array_unshift($values, $message);
$this->_retCode = CRM_Import_Parser::NO_MATCH;
}
}
} else {
//CRM-4148
//now we want to create new contact on update/fill also.
$createNewContact = true;
}
}
if (is_a($newContact, 'CRM_Contact_BAO_Contact')) {
$relationship = true;
} else {
if (is_a($error, 'CRM_Core_Error')) {
$newContact = $error;
$relationship = true;
}
}
}
//fixed CRM-4148
//now we create new contact in update/fill mode also.
if ($createNewContact) {
//CRM-4430, don't carry if not submitted.
foreach (array('prefix', 'suffix', 'gender') as $name) {
if (array_key_exists($name, $formatted)) {
if (in_array($name, array('prefix', 'suffix'))) {
$formattedName = "individual_{$name}";
$formatted[$formattedName] = CRM_Core_OptionGroup::getValue($formattedName, (string) $formatted[$name]);
} else {
$formatted[$name] = CRM_Core_OptionGroup::getValue($name, (string) $formatted[$name]);
}
}
}
$newContact = $this->createContact($formatted, $contactFields, $onDuplicate);
}
if (is_object($newContact) || $newContact instanceof CRM_Contact_BAO_Contact) {
$relationship = true;
$newContact = clone $newContact;
$this->_newContacts[] = $newContact->id;
//get return code if we create new contact in update mode, CRM-4148
if ($this->_updateWithId) {
$this->_retCode = CRM_Import_Parser::VALID;
}
} else {
if (civicrm_duplicate($newContact)) {
$relationship = true;
$contactID = $newContact['error_message']['params'][0];
if (!in_array($contactID, $this->_newContacts)) {
$this->_newContacts[] = $contactID;
}
}
}
if ($relationship) {
$primaryContactId = null;
if (civicrm_duplicate($newContact)) {
if (CRM_Utils_Rule::integer($newContact['error_message']['params'][0])) {
$primaryContactId = $newContact['error_message']['params'][0];
}
} else {
$primaryContactId = $newContact->id;
}
if ((civicrm_duplicate($newContact) || is_a($newContact, 'CRM_Contact_BAO_Contact')) && $primaryContactId) {
//relationship contact insert
foreach ($params as $key => $field) {
list($id, $first, $second) = CRM_Utils_System::explode('_', $key, 3);
if (!($first == 'a' && $second == 'b') && !($first == 'b' && $second == 'a')) {
continue;
}
$relationType = new CRM_Contact_DAO_RelationshipType();
$relationType->id = $id;
$relationType->find(true);
$direction = "contact_sub_type_{$second}";
$formatting = array('contact_type' => $params[$key]['contact_type']);
//set subtype for related contact CRM-5125
if (isset($relationType->{$direction})) {
//validation of related contact subtype for update mode
if ($relCsType = CRM_Utils_Array::value('contact_sub_type', $params[$key]) && $relCsType != $relationType->{$direction}) {
$errorMessage = ts("Mismatched or Invalid contact subtype found for this related contact");
array_unshift($values, $errorMessage);
return CRM_Import_Parser::NO_MATCH;
} else {
$formatting['contact_sub_type'] = $relationType->{$direction};
}
}
$relationType->free();
$contactFields = null;
$contactFields = CRM_Contact_DAO_Contact::import();
//Relation on the basis of External Identifier.
if (!CRM_Utils_Array::value('id', $params[$key]) && isset($params[$key]['external_identifier'])) {
$params[$key]['id'] = CRM_Core_DAO::getFieldValue('CRM_Contact_DAO_Contact', $params[$key]['external_identifier'], 'id', 'external_identifier');
}
// check for valid related contact id in update/fill mode, CRM-4424
if (in_array($onDuplicate, array(CRM_Import_Parser::DUPLICATE_UPDATE, CRM_Import_Parser::DUPLICATE_FILL)) && CRM_Utils_Array::value('id', $params[$key])) {
$relatedContactType = CRM_Core_DAO::getFieldValue('CRM_Contact_DAO_Contact', $params[$key]['id'], 'contact_type');
if (!$relatedContactType) {
$errorMessage = ts("No contact found for this related contact ID: %1", array(1 => $params[$key]['id']));
array_unshift($values, $errorMessage);
return CRM_Import_Parser::NO_MATCH;
} else {
//validation of related contact subtype for update mode
//CRM-5125
$relatedCsType = null;
if (CRM_Utils_Array::value('contact_sub_type', $formatting)) {
$relatedCsType = CRM_Core_DAO::getFieldValue('CRM_Contact_DAO_Contact', $params[$key]['id'], 'contact_sub_type');
}
if (!empty($relatedCsType) && (!CRM_Contact_BAO_ContactType::isAllowEdit($params[$key]['id'], $relatedCsType) || $relatedCsType != CRM_Utils_Array::value('contact_sub_type', $formatting))) {
$errorMessage = ts("Mismatched or Invalid contact subtype found for this related contact ID: %1", array(1 => $params[$key]['id']));
array_unshift($values, $errorMessage);
return CRM_Import_Parser::NO_MATCH;
} else {
// get related contact id to format data in update/fill mode,
//if external identifier is present, CRM-4423
$formatting['id'] = $params[$key]['id'];
}
}
}
//format common data, CRM-4062
$this->formatCommonData($field, $formatting, $contactFields);
//fixed for CRM-4148
if ($params[$key]['id']) {
$contact = array('contact_id' => $params[$key]['id']);
$defaults = array();
$relatedNewContact = CRM_Contact_BAO_Contact::retrieve($contact, $defaults);
} else {
$relatedNewContact = $this->createContact($formatting, $contactFields, $onDuplicate, null, false);
}
if (is_object($relatedNewContact) || $relatedNewContact instanceof CRM_Contact_BAO_Contact) {
$relatedNewContact = clone $relatedNewContact;
}
$matchedIDs = array();
// To update/fill contact, get the matching contact Ids if duplicate contact found
// otherwise get contact Id from object of related contact
if (is_array($relatedNewContact) && civicrm_error($relatedNewContact)) {
if (civicrm_duplicate($relatedNewContact)) {
$matchedIDs = explode(',', $relatedNewContact['error_message']['params'][0]);
} else {
$errorMessage = $relatedNewContact['error_message'];
array_unshift($values, $errorMessage);
$importRecordParams = array($statusFieldName => 'ERROR', "{$statusFieldName}Msg" => $errorMessage);
$this->updateImportRecord($values[count($values) - 1], $importRecordParams);
return CRM_Import_Parser::ERROR;
}
} else {
$matchedIDs[] = $relatedNewContact->id;
}
// update/fill related contact after getting matching Contact Ids, CRM-4424
if (in_array($onDuplicate, array(CRM_Import_Parser::DUPLICATE_UPDATE, CRM_Import_Parser::DUPLICATE_FILL))) {
//validation of related contact subtype for update mode
//CRM-5125
$relatedCsType = null;
if (CRM_Utils_Array::value('contact_sub_type', $formatting)) {
$relatedCsType = CRM_Core_DAO::getFieldValue('CRM_Contact_DAO_Contact', $matchedIDs[0], 'contact_sub_type');
}
if (!empty($relatedCsType) && (!CRM_Contact_BAO_ContactType::isAllowEdit($matchedIDs[0], $relatedCsType) || $relatedCsType != CRM_Utils_Array::value('contact_sub_type', $formatting))) {
$errorMessage = ts("Mismatched or Invalid contact subtype found for this related contact.");
array_unshift($values, $errorMessage);
return CRM_Import_Parser::NO_MATCH;
} else {
$updatedContact = $this->createContact($formatting, $contactFields, $onDuplicate, $matchedIDs[0]);
}
}
static $relativeContact = array();
if (civicrm_duplicate($relatedNewContact)) {
if (count($matchedIDs) >= 1) {
$relContactId = $matchedIDs[0];
//add relative contact to count during update & fill mode.
//logic to make count distinct by contact id.
if ($this->_newRelatedContacts || !empty($relativeContact)) {
$reContact = array_keys($relativeContact, $relContactId);
if (empty($reContact)) {
$this->_newRelatedContacts[] = $relativeContact[] = $relContactId;
}
} else {
$this->_newRelatedContacts[] = $relativeContact[] = $relContactId;
}
}
} else {
$relContactId = $relatedNewContact->id;
$this->_newRelatedContacts[] = $relativeContact[] = $relContactId;
}
if (civicrm_duplicate($relatedNewContact) || $relatedNewContact instanceof CRM_Contact_BAO_Contact) {
//fix for CRM-1993.Checks for duplicate related contacts
if (count($matchedIDs) >= 1) {
//if more than one duplicate contact
//found, create relationship with first contact
// now create the relationship record
$relationParams = array();
$relationParams = array('relationship_type_id' => $key, 'contact_check' => array($relContactId => 1), 'is_active' => 1, 'skipRecentView' => true);
// we only handle related contact success, we ignore failures for now
// at some point wold be nice to have related counts as separate
$relationIds = array('contact' => $primaryContactId);
list($valid, $invalid, $duplicate, $saved, $relationshipIds) = CRM_Contact_BAO_Relationship::create($relationParams, $relationIds);
CRM_Contact_BAO_Relationship::relatedMemberships($primaryContactId, $relationParams, $relationIds);
//handle current employer, CRM-3532
if ($valid) {
require_once 'CRM/Core/PseudoConstant.php';
$allRelationships = CRM_Core_PseudoConstant::relationshipType('name');
$relationshipTypeId = str_replace(array('_a_b', '_b_a'), array('', ''), $key);
$relationshipType = str_replace($relationshipTypeId . '_', '', $key);
$orgId = $individualId = null;
if ($allRelationships[$relationshipTypeId]["name_{$relationshipType}"] == 'Employee of') {
$orgId = $relContactId;
$individualId = $primaryContactId;
} else {
if ($allRelationships[$relationshipTypeId]["name_{$relationshipType}"] == 'Employer of') {
$orgId = $primaryContactId;
$individualId = $relContactId;
}
}
if ($orgId && $individualId) {
$currentEmpParams[$individualId] = $orgId;
require_once 'CRM/Contact/BAO/Contact/Utils.php';
CRM_Contact_BAO_Contact_Utils::setCurrentEmployer($currentEmpParams);
}
}
}
}
}
}
}
if ($this->_updateWithId) {
//return warning if street address is unparsed, CRM-5886
return $this->processMessage($values, $statusFieldName, $this->_retCode);
}
//dupe checking
if (is_array($newContact) && civicrm_error($newContact)) {
$code = null;
if (($code = CRM_Utils_Array::value('code', $newContact['error_message'])) && $code == CRM_Core_Error::DUPLICATE_CONTACT) {
$urls = array();
// need to fix at some stage and decide if the error will return an
// array or string, crude hack for now
if (is_array($newContact['error_message']['params'][0])) {
$cids = $newContact['error_message']['params'][0];
} else {
$cids = explode(',', $newContact['error_message']['params'][0]);
}
foreach ($cids as $cid) {
$urls[] = CRM_Utils_System::url('civicrm/contact/view', 'reset=1&cid=' . $cid, true);
}
$url_string = implode("\n", $urls);
// If we duplicate more than one record, skip no matter what
if (count($cids) > 1) {
$errorMessage = ts('Record duplicates multiple contacts');
$importRecordParams = array($statusFieldName => 'ERROR', "{$statusFieldName}Msg" => $errorMessage);
//combine error msg to avoid mismatch between error file columns.
$errorMessage .= "\n" . $url_string;
array_unshift($values, $errorMessage);
$this->updateImportRecord($values[count($values) - 1], $importRecordParams);
return CRM_Import_Parser::ERROR;
}
// Params only had one id, so shift it out
$contactId = array_shift($cids);
$cid = null;
$vals = array('contact_id' => $contactId);
if ($onDuplicate == CRM_Import_Parser::DUPLICATE_REPLACE) {
$result = civicrm_replace_contact_formatted($contactId, $formatted, $contactFields);
$cid = $result['result'];
} else {
if ($onDuplicate == CRM_Import_Parser::DUPLICATE_UPDATE) {
$newContact = $this->createContact($formatted, $contactFields, $onDuplicate, $contactId);
} else {
if ($onDuplicate == CRM_Import_Parser::DUPLICATE_FILL) {
$newContact = $this->createContact($formatted, $contactFields, $onDuplicate, $contactId);
}
}
}
// else skip does nothing and just returns an error code.
if ($cid) {
$contact = array('contact_id' => $cid);
$defaults = array();
$newContact = CRM_Contact_BAO_Contact::retrieve($contact, $defaults);
}
if (civicrm_error($newContact)) {
$contactID = $newContact['error_message']['params'][0];
if (!in_array($contactID, $this->_newContacts)) {
$this->_newContacts[] = $contactID;
}
}
//CRM-262 No Duplicate Checking
if ($onDuplicate == CRM_Import_Parser::DUPLICATE_SKIP) {
array_unshift($values, $url_string);
$importRecordParams = array($statusFieldName => 'DUPLICATE', "{$statusFieldName}Msg" => "Skipping duplicate record");
$this->updateImportRecord($values[count($values) - 1], $importRecordParams);
return CRM_Import_Parser::DUPLICATE;
}
$importRecordParams = array($statusFieldName => 'IMPORTED');
$this->updateImportRecord($values[count($values) - 1], $importRecordParams);
//return warning if street address is not parsed, CRM-5886
return $this->processMessage($values, $statusFieldName, CRM_Import_Parser::VALID);
} else {
// Not a dupe, so we had an error
$errorMessage = $newContact['error_message'];
array_unshift($values, $errorMessage);
$importRecordParams = array($statusFieldName => 'ERROR', "{$statusFieldName}Msg" => $errorMessage);
$this->updateImportRecord($values[count($values) - 1], $importRecordParams);
return CRM_Import_Parser::ERROR;
}
}
// sleep(3);
return $this->processMessage($values, $statusFieldName, CRM_Import_Parser::VALID);
}
/**
* Function to check duplicate contacts based on de-deupe parameters
*/
function civicrm_check_contact_dedupe(&$params)
{
static $cIndieFields = null;
static $defaultLocationId = null;
$contactType = $params['contact_type'];
if ($cIndieFields == null) {
require_once 'CRM/Contact/BAO/Contact.php';
$cTempIndieFields = CRM_Contact_BAO_Contact::importableFields($contactType);
$cIndieFields = $cTempIndieFields;
require_once "CRM/Core/BAO/LocationType.php";
$defaultLocation =& CRM_Core_BAO_LocationType::getDefault();
//set the value to default location id else set to 1
if (!($defaultLocationId = (int) $defaultLocation->id)) {
$defaultLocationId = 1;
}
}
require_once 'CRM/Contact/BAO/Query.php';
$locationFields = CRM_Contact_BAO_Query::$_locationSpecificFields;
$contactFormatted = array();
foreach ($params as $key => $field) {
if ($field == null || $field === '') {
continue;
}
if (is_array($field)) {
foreach ($field as $value) {
$break = false;
if (is_array($value)) {
foreach ($value as $name => $testForEmpty) {
if ($name !== 'phone_type' && ($testForEmpty === '' || $testForEmpty == null)) {
$break = true;
break;
}
}
} else {
$break = true;
}
if (!$break) {
_civicrm_add_formatted_param($value, $contactFormatted);
}
}
continue;
}
$value = array($key => $field);
// check if location related field, then we need to add primary location type
if (in_array($key, $locationFields)) {
$value['location_type_id'] = $defaultLocationId;
} else {
if (array_key_exists($key, $cIndieFields)) {
$value['contact_type'] = $contactType;
}
}
_civicrm_add_formatted_param($value, $contactFormatted);
}
$contactFormatted['contact_type'] = $contactType;
return _civicrm_duplicate_formatted_contact($contactFormatted);
}
