projects / civicrm-core.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
CRM-20527: batch data entry does not retain currency
[civicrm-core.git] / CRM / Core / BAO / UFGroup.php
1 <?php
2 /*
3 +--------------------------------------------------------------------+
4 | CiviCRM version 4.7 |
5 +--------------------------------------------------------------------+
6 | Copyright CiviCRM LLC (c) 2004-2017 |
7 +--------------------------------------------------------------------+
8 | This file is a part of CiviCRM. |
9 | |
10 | CiviCRM is free software; you can copy, modify, and distribute it |
11 | under the terms of the GNU Affero General Public License |
12 | Version 3, 19 November 2007 and the CiviCRM Licensing Exception. |
13 | |
14 | CiviCRM is distributed in the hope that it will be useful, but |
15 | WITHOUT ANY WARRANTY; without even the implied warranty of |
16 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. |
17 | See the GNU Affero General Public License for more details. |
18 | |
19 | You should have received a copy of the GNU Affero General Public |
20 | License and the CiviCRM Licensing Exception along |
21 | with this program; if not, contact CiviCRM LLC |
22 | at info[AT]civicrm[DOT]org. If you have questions about the |
23 | GNU Affero General Public License or the licensing of CiviCRM, |
24 | see the CiviCRM license FAQ at http://civicrm.org/licensing |
25 +--------------------------------------------------------------------+
26 */
27
28 /**
29 *
30 * @package CRM
31 * @copyright CiviCRM LLC (c) 2004-2017
32 */
33
34 /**
35 * UF group BAO class.
36 */
37 class CRM_Core_BAO_UFGroup extends CRM_Core_DAO_UFGroup {
38 const PUBLIC_VISIBILITY = 1,
39 ADMIN_VISIBILITY = 2,
40 LISTINGS_VISIBILITY = 4;
41
42 /**
43 * Cache the match clause used in this transaction.
44 *
45 * @var string
46 */
47 static $_matchFields = NULL;
48
49 /**
50 * Fetch object based on array of properties.
51 *
52 * @param array $params
53 * (reference) an assoc array of name/value pairs.
54 * @param array $defaults
55 * (reference) an assoc array to hold the flattened values.
56 *
57 * @return object
58 * CRM_Core_DAO_UFGroup object
59 */
60 public static function retrieve(&$params, &$defaults) {
61 return CRM_Core_DAO::commonRetrieve('CRM_Core_DAO_UFGroup', $params, $defaults);
62 }
63
64 /**
65 * Retrieve the first non-generic contact type
66 *
67 * @param int $id
68 * Id of uf_group.
69 *
70 * @return string
71 * contact type
72 */
73 public static function getContactType($id) {
74
75 $validTypes = array_filter(array_keys(CRM_Core_SelectValues::contactType()));
76 $validSubTypes = CRM_Contact_BAO_ContactType::subTypeInfo();
77
78 $typesParts = explode(CRM_Core_DAO::VALUE_SEPARATOR, CRM_Core_DAO::getFieldValue('CRM_Core_DAO_UFGroup', $id, 'group_type'));
79 $types = explode(',', $typesParts[0]);
80
81 $cType = NULL;
82 foreach ($types as $type) {
83 if (in_array($type, $validTypes)) {
84 $cType = $type;
85 }
86 elseif (array_key_exists($type, $validSubTypes)) {
87 $cType = CRM_Utils_Array::value('parent', $validSubTypes[$type]);
88 }
89 if ($cType) {
90 break;
91 }
92 }
93
94 return $cType;
95 }
96
97 /**
98 * Get the form title.
99 *
100 * @param int $id
101 * Id of uf_form.
102 *
103 * @return string
104 * title
105 *
106 */
107 public static function getTitle($id) {
108 return CRM_Core_DAO::getFieldValue('CRM_Core_DAO_UFGroup', $id, 'title');
109 }
110
111 /**
112 * Update the is_active flag in the db.
113 *
114 * @param int $id
115 * Id of the database record.
116 * @param bool $is_active
117 * Value we want to set the is_active field.
118 *
119 * @return Object
120 * CRM_Core_DAO_UFGroup object on success, null otherwise
121 */
122 public static function setIsActive($id, $is_active) {
123 return CRM_Core_DAO::setFieldValue('CRM_Core_DAO_UFGroup', $id, 'is_active', $is_active);
124 }
125
126 /**
127 * Get all the registration fields.
128 *
129 * @param int $action
130 * What action are we doing.
131 * @param int $mode
132 * Mode.
133 *
134 * @param null $ctype
135 *
136 * @return array
137 * the fields that are needed for registration
138 */
139 public static function getRegistrationFields($action, $mode, $ctype = NULL) {
140 if ($mode & CRM_Profile_Form::MODE_REGISTER) {
141 $ufGroups = CRM_Core_BAO_UFGroup::getModuleUFGroup('User Registration');
142 }
143 else {
144 $ufGroups = CRM_Core_BAO_UFGroup::getModuleUFGroup('Profile');
145 }
146
147 if (!is_array($ufGroups)) {
148 return FALSE;
149 }
150
151 $fields = array();
152
153 foreach ($ufGroups as $id => $title) {
154 if ($ctype) {
155 $fieldType = CRM_Core_BAO_UFField::getProfileType($id);
156 if (($fieldType != 'Contact') &&
157 ($fieldType != $ctype) &&
158 !CRM_Contact_BAO_ContactType::isExtendsContactType($fieldType, $ctype)
159 ) {
160 continue;
161 }
162 if (CRM_Contact_BAO_ContactType::isaSubType($fieldType)) {
163 $profileSubType = $fieldType;
164 }
165 }
166
167 $subset = self::getFields($id, TRUE, $action,
168 NULL, NULL, FALSE, NULL, TRUE, $ctype
169 );
170
171 // we do not allow duplicates. the first field is the winner
172 foreach ($subset as $name => $field) {
173 if (empty($fields[$name])) {
174 $fields[$name] = $field;
175 }
176 }
177 }
178
179 return $fields;
180 }
181
182 /**
183 * Get all the listing fields.
184 *
185 * @param int $action
186 * What action are we doing.
187 * @param int $visibility
188 * Visibility of fields we are interested in.
189 * @param bool $considerSelector
190 * Whether to consider the in_selector parameter.
191 * @param array $ufGroupIds
192 * @param bool $searchable
193 *
194 * @param null $restrict
195 * @param bool $skipPermission
196 * @param int $permissionType
197 * @return array
198 * the fields that are listings related
199 */
200 public static function getListingFields(
201 $action,
202 $visibility,
203 $considerSelector = FALSE,
204 $ufGroupIds = NULL,
205 $searchable = NULL,
206 $restrict = NULL,
207 $skipPermission = FALSE,
208 $permissionType = CRM_Core_Permission::SEARCH
209 ) {
210 if ($ufGroupIds) {
211 $subset = self::getFields($ufGroupIds, FALSE, $action,
212 $visibility, $searchable,
213 FALSE, $restrict,
214 $skipPermission,
215 NULL,
216 $permissionType
217 );
218 if ($considerSelector) {
219 // drop the fields not meant for the selector
220 foreach ($subset as $name => $field) {
221 if (!$field['in_selector']) {
222 unset($subset[$name]);
223 }
224 }
225 }
226 $fields = $subset;
227 }
228 else {
229 $ufGroups = CRM_Core_PseudoConstant::get('CRM_Core_DAO_UFField', 'uf_group_id');
230
231 $fields = array();
232 foreach ($ufGroups as $id => $title) {
233 $subset = self::getFields($id, FALSE, $action,
234 $visibility, $searchable,
235 FALSE, $restrict,
236 $skipPermission,
237 NULL,
238 $permissionType
239 );
240 if ($considerSelector) {
241 // drop the fields not meant for the selector
242 foreach ($subset as $name => $field) {
243 if (!$field['in_selector']) {
244 unset($subset[$name]);
245 }
246 }
247 }
248 $fields = array_merge($fields, $subset);
249 }
250 }
251 return $fields;
252 }
253
254 /**
255 * Get all the fields that belong to the group with the name title,
256 * and format for use with buildProfile. This is the SQL analog of
257 * formatUFFields().
258 *
259 * @param mix $id
260 * The id of the UF group or ids of ufgroup.
261 * @param bool|int $register are we interested in registration fields
262 * @param int $action
263 * What action are we doing.
264 * @param int $visibility
265 * Visibility of fields we are interested in.
266 * @param $searchable
267 * @param bool $showAll
268 * @param string $restrict
269 * Should we restrict based on a specified profile type.
270 * @param bool $skipPermission
271 * @param null $ctype
272 * @param int $permissionType
273 * @param string $orderBy
274 * @param null $orderProfiles
275 *
276 * @param bool $eventProfile
277 *
278 * @return array
279 * The fields that belong to this ufgroup(s)
280 * @throws \Exception
281 */
282 public static function getFields(
283 $id,
284 $register = FALSE,
285 $action = NULL,
286 $visibility = NULL,
287 $searchable = NULL,
288 $showAll = FALSE,
289 $restrict = NULL,
290 $skipPermission = FALSE,
291 $ctype = NULL,
292 $permissionType = CRM_Core_Permission::CREATE,
293 $orderBy = 'field_name',
294 $orderProfiles = NULL,
295 $eventProfile = FALSE
296 ) {
297 if (!is_array($id)) {
298 $id = CRM_Utils_Type::escape($id, 'Positive');
299 $profileIds = array($id);
300 }
301 else {
302 $profileIds = $id;
303 }
304
305 $gids = implode(',', $profileIds);
306 $params = array();
307 if ($restrict) {
308 $query = "SELECT g.* from civicrm_uf_group g
309 LEFT JOIN civicrm_uf_join j ON (j.uf_group_id = g.id)
310 WHERE g.id IN ( {$gids} )
311 AND ((j.uf_group_id IN ( {$gids} ) AND j.module = %1) OR g.is_reserved = 1 )
312 ";
313 $params = array(1 => array($restrict, 'String'));
314 }
315 else {
316 $query = "SELECT g.* from civicrm_uf_group g WHERE g.id IN ( {$gids} ) ";
317 }
318
319 if (!$showAll) {
320 $query .= " AND g.is_active = 1";
321 }
322
323 $checkPermission = array(
324 array(
325 'administer CiviCRM',
326 'manage event profiles',
327 ),
328 );
329 if ($eventProfile && CRM_Core_Permission::check($checkPermission)) {
330 $skipPermission = TRUE;
331 }
332
333 // add permissioning for profiles only if not registration
334 if (!$skipPermission) {
335 $permissionClause = CRM_Core_Permission::ufGroupClause($permissionType, 'g.');
336 $query .= " AND $permissionClause ";
337 }
338
339 if ($orderProfiles AND count($profileIds) > 1) {
340 $query .= " ORDER BY FIELD( g.id, {$gids} )";
341 }
342 $group = CRM_Core_DAO::executeQuery($query, $params);
343 $fields = array();
344 $validGroup = FALSE;
345
346 while ($group->fetch()) {
347 $validGroup = TRUE;
348 $query = self::createUFFieldQuery($group->id, $searchable, $showAll, $visibility, $orderBy);
349 $field = CRM_Core_DAO::executeQuery($query);
350
351 $importableFields = self::getProfileFieldMetadata($showAll);
352 list($customFields, $addressCustomFields) = self::getCustomFields($ctype);
353
354 while ($field->fetch()) {
355 list($name, $formattedField) = self::formatUFField($group, $field, $customFields, $addressCustomFields, $importableFields, $permissionType);
356 if ($formattedField !== NULL) {
357 $fields[$name] = $formattedField;
358 }
359 }
360 $field->free();
361 }
362
363 if (empty($fields) && !$validGroup) {
364 CRM_Core_Error::fatal(ts('The requested Profile (gid=%1) is disabled OR it is not configured to be used for \'Profile\' listings in its Settings OR there is no Profile with that ID OR you do not have permission to access this profile. Please contact the site administrator if you need assistance.',
365 array(1 => implode(',', $profileIds))
366 ));
367 }
368 else {
369 self::reformatProfileFields($fields);
370 }
371
372 return $fields;
373 }
374
375 /**
376 * Format a list of UFFields for use with buildProfile. This is the in-memory analog
377 * of getFields().
378 *
379 * @param array $groupArr
380 * (mimic CRM_UF_DAO_UFGroup).
381 * @param array $fieldArrs
382 * List of fields (each mimics CRM_UF_DAO_UFField).
383 * @param bool $visibility
384 * Visibility of fields we are interested in.
385 * @param bool $searchable
386 * @param bool $showAll
387 * @param null $ctype
388 * @param int $permissionType
389 *
390 * @return array
391 * @see self::getFields
392 */
393 public static function formatUFFields(
394 $groupArr,
395 $fieldArrs,
396 $visibility = NULL,
397 $searchable = NULL,
398 $showAll = FALSE,
399 $ctype = NULL,
400 $permissionType = CRM_Core_Permission::CREATE
401 ) {
402 // $group = new CRM_Core_DAO_UFGroup();
403 // $group->copyValues($groupArr); // no... converts string('') to string('null')
404 $group = (object) $groupArr;
405
406 // Refactoring note: The $fieldArrs here may be slightly different than the $ufFields
407 // used by calculateGroupType, but I don't think the missing fields matter, and -- if
408 // they did -- the obvious fix would produce mutual recursion.
409 $ufGroupType = self::_calculateGroupType($fieldArrs);
410 $profileType = CRM_Core_BAO_UFField::calculateProfileType(implode(',', $ufGroupType));
411 $contactActivityProfile = CRM_Core_BAO_UFField::checkContactActivityProfileTypeByGroupType(implode(',', $ufGroupType));
412 $importableFields = self::getImportableFields($showAll, $profileType, $contactActivityProfile);
413 list($customFields, $addressCustomFields) = self::getCustomFields($ctype);
414
415 $formattedFields = array();
416 foreach ($fieldArrs as $fieldArr) {
417 $field = (object) $fieldArr;
418 if (!self::filterUFField($field, $searchable, $showAll, $visibility)) {
419 continue;
420 }
421
422 list($name, $formattedField) = self::formatUFField($group, $field, $customFields, $addressCustomFields, $importableFields, $permissionType);
423 if ($formattedField !== NULL) {
424 $formattedFields[$name] = $formattedField;
425 }
426 }
427 return $formattedFields;
428 }
429
430 /**
431 * Prepare a field for rendering with CRM_Core_BAO_UFGroup::buildProfile.
432 *
433 * @param CRM_Core_DAO_UFGroup|CRM_Core_DAO $group
434 * @param CRM_Core_DAO_UFField|CRM_Core_DAO $field
435 * @param array $customFields
436 * @param array $addressCustomFields
437 * @param array $importableFields
438 * @param int $permissionType
439 * Eg CRM_Core_Permission::CREATE.
440 * @return array
441 */
442 protected static function formatUFField(
443 $group,
444 $field,
445 $customFields,
446 $addressCustomFields,
447 $importableFields,
448 $permissionType = CRM_Core_Permission::CREATE
449 ) {
450 $name = $field->field_name;
451 $title = $field->label;
452
453 $addressCustom = FALSE;
454 if (in_array($permissionType, array(
455 CRM_Core_Permission::CREATE,
456 CRM_Core_Permission::EDIT,
457 )) &&
458 in_array($field->field_name, array_keys($addressCustomFields))
459 ) {
460 $addressCustom = TRUE;
461 $name = "address_{$name}";
462 }
463 if ($field->field_name == 'url') {
464 $name .= "-{$field->website_type_id}";
465 }
466 elseif (!empty($field->location_type_id)) {
467 $name .= "-{$field->location_type_id}";
468 }
469 else {
470 $locationFields = self::getLocationFields();
471 if (in_array($field->field_name, $locationFields) || $addressCustom) {
472 $name .= '-Primary';
473 }
474 }
475
476 if (isset($field->phone_type_id)) {
477 $name .= "-{$field->phone_type_id}";
478 }
479 $fieldMetaData = CRM_Utils_Array::value($name, $importableFields, (isset($importableFields[$field->field_name]) ? $importableFields[$field->field_name] : array()));
480
481 // No lie: this is bizarre; why do we need to mix so many UFGroup properties into UFFields?
482 // I guess to make field self sufficient with all the required data and avoid additional calls
483 $formattedField = array(
484 'name' => $name,
485 'groupTitle' => $group->title,
486 'groupName' => $group->name,
487 'groupHelpPre' => empty($group->help_pre) ? '' : $group->help_pre,
488 'groupHelpPost' => empty($group->help_post) ? '' : $group->help_post,
489 'title' => $title,
490 'where' => CRM_Utils_Array::value('where', CRM_Utils_Array::value($field->field_name, $importableFields)),
491 'attributes' => CRM_Core_DAO::makeAttribute(CRM_Utils_Array::value($field->field_name, $importableFields)),
492 'is_required' => $field->is_required,
493 'is_view' => $field->is_view,
494 'help_pre' => $field->help_pre,
495 'help_post' => $field->help_post,
496 'visibility' => $field->visibility,
497 'in_selector' => $field->in_selector,
498 'rule' => CRM_Utils_Array::value('rule', CRM_Utils_Array::value($field->field_name, $importableFields)),
499 'location_type_id' => isset($field->location_type_id) ? $field->location_type_id : NULL,
500 'website_type_id' => isset($field->website_type_id) ? $field->website_type_id : NULL,
501 'phone_type_id' => isset($field->phone_type_id) ? $field->phone_type_id : NULL,
502 'group_id' => $group->id,
503 'add_to_group_id' => isset($group->add_to_group_id) ? $group->add_to_group_id : NULL,
504 'add_captcha' => isset($group->add_captcha) ? $group->add_captcha : NULL,
505 'field_type' => $field->field_type,
506 'field_id' => $field->id,
507 'pseudoconstant' => CRM_Utils_Array::value(
508 'pseudoconstant',
509 CRM_Utils_Array::value($field->field_name, $importableFields)
510 ),
511 // obsolete this when we remove the name / dbName discrepancy with gender/suffix/prefix
512 'dbName' => CRM_Utils_Array::value(
513 'dbName',
514 CRM_Utils_Array::value($field->field_name, $importableFields)
515 ),
516 'skipDisplay' => 0,
517 'data_type' => CRM_Utils_Type::getDataTypeFromFieldMetadata($fieldMetaData),
518 'bao' => CRM_Utils_Array::value('bao', $fieldMetaData),
519 );
520
521 $formattedField = CRM_Utils_Date::addDateMetadataToField($fieldMetaData, $formattedField);
522
523 //adding custom field property
524 if (substr($field->field_name, 0, 6) == 'custom' ||
525 substr($field->field_name, 0, 14) === 'address_custom'
526 ) {
527 // if field is not present in customFields, that means the user
528 // DOES NOT HAVE permission to access that field
529 if (array_key_exists($field->field_name, $customFields)) {
530 $formattedField['is_search_range'] = $customFields[$field->field_name]['is_search_range'];
531 // fix for CRM-1994
532 $formattedField['options_per_line'] = $customFields[$field->field_name]['options_per_line'];
533 $formattedField['html_type'] = $customFields[$field->field_name]['html_type'];
534
535 if (CRM_Utils_Array::value('html_type', $formattedField) == 'Select Date') {
536 $formattedField['date_format'] = $customFields[$field->field_name]['date_format'];
537 $formattedField['time_format'] = $customFields[$field->field_name]['time_format'];
538 $formattedField['is_datetime_field'] = TRUE;
539 $formattedField['smarty_view_format'] = CRM_Utils_Date::getDateFieldViewFormat($formattedField['date_format']);
540 }
541
542 $formattedField['is_multi_summary'] = $field->is_multi_summary;
543 return array($name, $formattedField);
544 }
545 else {
546 $formattedField = NULL;
547 return array($name, $formattedField);
548 }
549 }
550 return array($name, $formattedField);
551 }
552
553 /**
554 * Create a query to find all visible UFFields in a UFGroup.
555 *
556 * This is the SQL-variant of checkUFFieldDisplayable().
557 *
558 * @param int $groupId
559 * @param bool $searchable
560 * @param bool $showAll
561 * @param int $visibility
562 * @param string $orderBy
563 * Comma-delimited list of SQL columns.
564 * @return string
565 */
566 protected static function createUFFieldQuery($groupId, $searchable, $showAll, $visibility, $orderBy) {
567 $where = " WHERE uf_group_id = {$groupId}";
568
569 if ($searchable) {
570 $where .= " AND is_searchable = 1";
571 }
572
573 if (!$showAll) {
574 $where .= " AND is_active = 1";
575 }
576
577 if ($visibility) {
578 $clause = array();
579 if ($visibility & self::PUBLIC_VISIBILITY) {
580 $clause[] = 'visibility = "Public Pages"';
581 }
582 if ($visibility & self::ADMIN_VISIBILITY) {
583 $clause[] = 'visibility = "User and User Admin Only"';
584 }
585 if ($visibility & self::LISTINGS_VISIBILITY) {
586 $clause[] = 'visibility = "Public Pages and Listings"';
587 }
588 if (!empty($clause)) {
589 $where .= ' AND ( ' . implode(' OR ', $clause) . ' ) ';
590 }
591 }
592
593 $query = "SELECT * FROM civicrm_uf_field $where ORDER BY weight";
594 if ($orderBy) {
595 $query .= ", " . $orderBy;
596 return $query;
597 }
598 return $query;
599 }
600
601 /**
602 * Create a query to find all visible UFFields in a UFGroup.
603 *
604 * This is the PHP in-memory variant of createUFFieldQuery().
605 *
606 * @param CRM_Core_DAO_UFField|CRM_Core_DAO $field
607 * @param bool $searchable
608 * @param bool $showAll
609 * @param int $visibility
610 * @return bool
611 * TRUE if field is displayable
612 */
613 protected static function filterUFField($field, $searchable, $showAll, $visibility) {
614 if ($searchable && $field->is_searchable != 1) {
615 return FALSE;
616 }
617
618 if (!$showAll && $field->is_active != 1) {
619 return FALSE;
620 }
621
622 if ($visibility) {
623 $allowedVisibilities = array();
624 if ($visibility & self::PUBLIC_VISIBILITY) {
625 $allowedVisibilities[] = 'Public Pages';
626 }
627 if ($visibility & self::ADMIN_VISIBILITY) {
628 $allowedVisibilities[] = 'User and User Admin Only';
629 }
630 if ($visibility & self::LISTINGS_VISIBILITY) {
631 $allowedVisibilities[] = 'Public Pages and Listings';
632 }
633 // !empty($allowedVisibilities) seems silly to me, but it is equivalent to the pre-existing SQL
634 if (!empty($allowedVisibilities) && !in_array($field->visibility, $allowedVisibilities)) {
635 return FALSE;
636 }
637 }
638
639 return TRUE;
640 }
641
642 /**
643 * Get a list of filtered field metadata.
644 *
645 * @deprecated use getProfileFieldMetadata
646 *
647 * @param $showAll
648 * @param $profileType
649 * @param $contactActivityProfile
650 * @param bool $filterMode
651 * Filter mode means you are using importable fields for filtering rather than just getting metadata.
652 * With filter mode = FALSE BOTH activity fields and component fields are returned.
653 * I can't see why you would ever want to use this function in filter mode as the component fields are
654 * still unfiltered. However, I feel scared enough to leave it as it is. I have marked this function as
655 * deprecated and am recommending the wrapper 'getProfileFieldMetadata' in order to try to
656 * send this confusion to history.
657 *
658 * @return array
659 */
660 protected static function getImportableFields($showAll, $profileType, $contactActivityProfile, $filterMode = TRUE) {
661 if (!$showAll) {
662 $importableFields = CRM_Contact_BAO_Contact::importableFields('All', FALSE, FALSE, FALSE, TRUE, TRUE);
663 }
664 else {
665 $importableFields = CRM_Contact_BAO_Contact::importableFields('All', FALSE, TRUE, FALSE, TRUE, TRUE);
666 }
667
668 $activityFields = CRM_Activity_BAO_Activity::getProfileFields();
669 $componentFields = CRM_Core_Component::getQueryFields();
670 if ($filterMode == TRUE) {
671 if ($profileType == 'Activity' || $contactActivityProfile) {
672 $importableFields = array_merge($importableFields, $activityFields);
673 }
674 else {
675 $importableFields = array_merge($importableFields, $componentFields);
676 }
677 }
678 else {
679 $importableFields = array_merge($importableFields, $activityFields, $componentFields);
680 }
681
682 $importableFields['group']['title'] = ts('Group(s)');
683 $importableFields['group']['where'] = NULL;
684 $importableFields['tag']['title'] = ts('Tag(s)');
685 $importableFields['tag']['where'] = NULL;
686 return $importableFields;
687 }
688
689 /**
690 * Get the metadata for all potential profile fields.
691 *
692 * @param bool $isIncludeInactive
693 * Should disabled fields be included.
694 *
695 * @return array
696 * Field metadata for all fields that might potentially be in a profile.
697 */
698 protected static function getProfileFieldMetadata($isIncludeInactive) {
699 return self::getImportableFields($isIncludeInactive, NULL, NULL, NULL, TRUE);
700 }
701
702 /**
703 * Get the fields relating to locations.
704 *
705 * @return array
706 */
707 public static function getLocationFields() {
708 static $locationFields = array(
709 'street_address',
710 'supplemental_address_1',
711 'supplemental_address_2',
712 'supplemental_address_3',
713 'city',
714 'postal_code',
715 'postal_code_suffix',
716 'geo_code_1',
717 'geo_code_2',
718 'state_province',
719 'country',
720 'county',
721 'phone',
722 'phone_and_ext',
723 'email',
724 'im',
725 'address_name',
726 'phone_ext',
727 );
728 return $locationFields;
729 }
730
731 /**
732 * @param $ctype
733 *
734 * @return mixed
735 */
736 protected static function getCustomFields($ctype) {
737 static $customFieldCache = array();
738 if (!isset($customFieldCache[$ctype])) {
739 $customFields = CRM_Core_BAO_CustomField::getFieldsForImport($ctype, FALSE, FALSE, FALSE, TRUE, TRUE);
740
741 // hack to add custom data for components
742 $components = array('Contribution', 'Participant', 'Membership', 'Activity', 'Case');
743 foreach ($components as $value) {
744 $customFields = array_merge($customFields, CRM_Core_BAO_CustomField::getFieldsForImport($value));
745 }
746 $addressCustomFields = CRM_Core_BAO_CustomField::getFieldsForImport('Address');
747 $customFields = array_merge($customFields, $addressCustomFields);
748 $customFieldCache[$ctype] = array($customFields, $addressCustomFields);
749 }
750 return $customFieldCache[$ctype];
751 }
752
753 /**
754 * Check the data validity.
755 *
756 * @param int $userID
757 * The user id that we are actually editing.
758 * @param string $name
759 * The machine-name of the group we are interested in.
760 * @param bool $register
761 * @param int $action
762 * The action of the form.
763 *
764 * @pram boolean $register is this the registrtion form
765 * @return bool
766 * true if form is valid
767 */
768 public static function isValid($userID, $name, $register = FALSE, $action = NULL) {
769 if ($register) {
770 $controller = new CRM_Core_Controller_Simple('CRM_Profile_Form_Dynamic',
771 ts('Dynamic Form Creator'),
772 $action
773 );
774 $controller->set('id', $userID);
775 $controller->set('register', 1);
776 $controller->process();
777 return $controller->validate();
778 }
779 else {
780 // make sure we have a valid group
781 $group = new CRM_Core_DAO_UFGroup();
782
783 $group->name = $name;
784
785 if ($group->find(TRUE) && $userID) {
786 $controller = new CRM_Core_Controller_Simple('CRM_Profile_Form_Dynamic', ts('Dynamic Form Creator'), $action);
787 $controller->set('gid', $group->id);
788 $controller->set('id', $userID);
789 $controller->set('register', 0);
790 $controller->process();
791 return $controller->validate();
792 }
793 return TRUE;
794 }
795 }
796
797 /**
798 * Get the html for the form that represents this particular group.
799 *
800 * @param int $userID
801 * The user id that we are actually editing.
802 * @param string $title
803 * The title of the group we are interested in.
804 * @param int $action
805 * The action of the form.
806 * @param bool $register
807 * Is this the registration form.
808 * @param bool $reset
809 * Should we reset the form?.
810 * @param int $profileID
811 * Do we have the profile ID?.
812 *
813 * @param bool $doNotProcess
814 * @param null $ctype
815 *
816 * @return string
817 * the html for the form on success, otherwise empty string
818 */
819 public static function getEditHTML(
820 $userID,
821 $title,
822 $action = NULL,
823 $register = FALSE,
824 $reset = FALSE,
825 $profileID = NULL,
826 $doNotProcess = FALSE,
827 $ctype = NULL
828 ) {
829
830 if ($register) {
831 $controller = new CRM_Core_Controller_Simple('CRM_Profile_Form_Dynamic',
832 ts('Dynamic Form Creator'),
833 $action
834 );
835 if ($reset || $doNotProcess) {
836 // hack to make sure we do not process this form
837 $oldQFDefault = CRM_Utils_Array::value('_qf_default',
838 $_POST
839 );
840 unset($_POST['_qf_default']);
841 unset($_REQUEST['_qf_default']);
842 if ($reset) {
843 $controller->reset();
844 }
845 }
846
847 $controller->set('id', $userID);
848 $controller->set('register', 1);
849 $controller->set('skipPermission', 1);
850 $controller->set('ctype', $ctype);
851 $controller->process();
852 if ($doNotProcess || !empty($_POST)) {
853 $controller->validate();
854 }
855 $controller->setEmbedded(TRUE);
856
857 //CRM-5839 - though we want to process form, get the control back.
858 $controller->setSkipRedirection(($doNotProcess) ? FALSE : TRUE);
859
860 $controller->run();
861
862 // we are done processing so restore the POST/REQUEST vars
863 if (($reset || $doNotProcess) && $oldQFDefault) {
864 $_POST['_qf_default'] = $_REQUEST['_qf_default'] = $oldQFDefault;
865 }
866
867 $template = CRM_Core_Smarty::singleton();
868
869 // Hide CRM error messages if they are displayed using drupal form_set_error.
870 if (!empty($_POST)) {
871 $template->assign('suppressForm', TRUE);
872 }
873
874 return trim($template->fetch('CRM/Profile/Form/Dynamic.tpl'));
875 }
876 else {
877 if (!$profileID) {
878 // make sure we have a valid group
879 $group = new CRM_Core_DAO_UFGroup();
880
881 $group->title = $title;
882
883 if ($group->find(TRUE)) {
884 $profileID = $group->id;
885 }
886 }
887
888 if ($profileID) {
889 // make sure profileID and ctype match if ctype exists
890 if ($ctype) {
891 $profileType = CRM_Core_BAO_UFField::getProfileType($profileID);
892 if (CRM_Contact_BAO_ContactType::isaSubType($profileType)) {
893 $profileType = CRM_Contact_BAO_ContactType::getBasicType($profileType);
894 }
895
896 if (($profileType != 'Contact') && ($profileType != $ctype)) {
897 return NULL;
898 }
899 }
900
901 $controller = new CRM_Core_Controller_Simple('CRM_Profile_Form_Dynamic',
902 ts('Dynamic Form Creator'),
903 $action
904 );
905 if ($reset) {
906 $controller->reset();
907 }
908 $controller->set('gid', $profileID);
909 $controller->set('id', $userID);
910 $controller->set('register', 0);
911 $controller->set('skipPermission', 1);
912 if ($ctype) {
913 $controller->set('ctype', $ctype);
914 }
915 $controller->process();
916 $controller->setEmbedded(TRUE);
917
918 //CRM-5846 - give the control back to drupal.
919 $controller->setSkipRedirection(($doNotProcess) ? FALSE : TRUE);
920 $controller->run();
921
922 $template = CRM_Core_Smarty::singleton();
923
924 // Hide CRM error messages if they are displayed using drupal form_set_error.
925 if (!empty($_POST) && CRM_Core_Config::singleton()->userFramework == 'Drupal') {
926 if (arg(0) == 'user' || (arg(0) == 'admin' && arg(1) == 'people')) {
927 $template->assign('suppressForm', TRUE);
928 }
929 }
930
931 $templateFile = "CRM/Profile/Form/{$profileID}/Dynamic.tpl";
932 if (!$template->template_exists($templateFile)) {
933 $templateFile = 'CRM/Profile/Form/Dynamic.tpl';
934 }
935 return trim($template->fetch($templateFile));
936 }
937 else {
938 $userEmail = CRM_Contact_BAO_Contact_Location::getEmailDetails($userID);
939
940 // if post not empty then only proceed
941 if (!empty($_POST)) {
942 // get the new email
943 $config = CRM_Core_Config::singleton();
944 $email = CRM_Utils_Array::value('mail', $_POST);
945
946 if (CRM_Utils_Rule::email($email) && ($email != $userEmail[1])) {
947 CRM_Core_BAO_UFMatch::updateContactEmail($userID, $email);
948 }
949 }
950 }
951 }
952 return '';
953 }
954
955 /**
956 * Given a contact id and a field set, return the values from the db.
957 *
958 * @param int $cid
959 * @param array $fields
960 * The profile fields of interest.
961 * @param array $values
962 * The values for the above fields.
963 * @param bool $searchable
964 * Searchable or not.
965 * @param array $componentWhere
966 * Component condition.
967 * @param bool $absolute
968 * Return urls in absolute form (useful when sending an email).
969 * @param null $additionalWhereClause
970 *
971 * @return null|array
972 */
973 public static function getValues(
974 $cid, &$fields, &$values,
975 $searchable = TRUE, $componentWhere = NULL,
976 $absolute = FALSE, $additionalWhereClause = NULL
977 ) {
978 if (empty($cid) && empty($componentWhere)) {
979 return NULL;
980 }
981
982 // get the contact details (hier)
983 $returnProperties = CRM_Contact_BAO_Contact::makeHierReturnProperties($fields);
984 $params = $cid ? array(array('contact_id', '=', $cid, 0, 0)) : array();
985
986 // add conditions specified by components. eg partcipant_id etc
987 if (!empty($componentWhere)) {
988 $params = array_merge($params, $componentWhere);
989 }
990
991 $query = new CRM_Contact_BAO_Query($params, $returnProperties, $fields);
992
993 $details = $query->searchQuery(0, 0, NULL, FALSE, FALSE,
994 FALSE, FALSE, FALSE, $additionalWhereClause);
995 if (!$details->fetch()) {
996 return;
997 }
998 $query->convertToPseudoNames($details);
999 $config = CRM_Core_Config::singleton();
1000
1001 $locationTypes = CRM_Core_PseudoConstant::get('CRM_Core_DAO_Address', 'location_type_id');
1002 $imProviders = CRM_Core_PseudoConstant::get('CRM_Core_DAO_IM', 'provider_id');
1003 $websiteTypes = CRM_Core_PseudoConstant::get('CRM_Core_DAO_Website', 'website_type_id');
1004
1005 $multipleFields = array('url');
1006
1007 //start of code to set the default values
1008 foreach ($fields as $name => $field) {
1009 // fix for CRM-3962
1010 if ($name == 'id') {
1011 $name = 'contact_id';
1012 }
1013
1014 // skip fields that should not be displayed separately
1015 if (!empty($field['skipDisplay'])) {
1016 continue;
1017 }
1018
1019 // Create a unique, non-empty index for each field.
1020 $index = $field['title'];
1021 if ($index === '') {
1022 $index = ' ';
1023 }
1024 while (array_key_exists($index, $values)) {
1025 $index .= ' ';
1026 }
1027
1028 $params[$index] = $values[$index] = '';
1029 $customFieldName = NULL;
1030 // hack for CRM-665
1031 if (isset($details->$name) || $name == 'group' || $name == 'tag') {
1032 // to handle gender / suffix / prefix
1033 if (in_array(substr($name, 0, -3), array('gender', 'prefix', 'suffix'))) {
1034 $params[$index] = $details->$name;
1035 $values[$index] = $details->$name;
1036 }
1037 elseif (in_array($name, CRM_Contact_BAO_Contact::$_greetingTypes)) {
1038 $dname = $name . '_display';
1039 $values[$index] = $details->$dname;
1040 $name = $name . '_id';
1041 $params[$index] = $details->$name;
1042 }
1043 elseif (in_array($name, array(
1044 'state_province',
1045 'country',
1046 'county',
1047 ))) {
1048 $values[$index] = $details->$name;
1049 $idx = $name . '_id';
1050 $params[$index] = $details->$idx;
1051 }
1052 elseif ($name === 'preferred_language') {
1053 $params[$index] = $details->$name;
1054 $values[$index] = CRM_Core_PseudoConstant::getLabel('CRM_Contact_DAO_Contact', 'preferred_language', $details->$name);
1055 }
1056 elseif ($name == 'group') {
1057 $groups = CRM_Contact_BAO_GroupContact::getContactGroup($cid, 'Added', NULL, FALSE, TRUE);
1058 $title = $ids = array();
1059
1060 foreach ($groups as $g) {
1061 // CRM-8362: User and User Admin visibility groups should be included in display if user has
1062 // VIEW permission on that group
1063 $groupPerm = CRM_Contact_BAO_Group::checkPermission($g['group_id'], TRUE);
1064
1065 if ($g['visibility'] != 'User and User Admin Only' ||
1066 CRM_Utils_Array::key(CRM_Core_Permission::VIEW, $groupPerm)
1067 ) {
1068 $title[] = $g['title'];
1069 if ($g['visibility'] == 'Public Pages') {
1070 $ids[] = $g['group_id'];
1071 }
1072 }
1073 }
1074 $values[$index] = implode(', ', $title);
1075 $params[$index] = implode(',', $ids);
1076 }
1077 elseif ($name == 'tag') {
1078 $entityTags = CRM_Core_BAO_EntityTag::getTag($cid);
1079 $allTags = CRM_Core_PseudoConstant::get('CRM_Core_DAO_EntityTag', 'tag_id', array('onlyActive' => FALSE));
1080 $title = array();
1081 foreach ($entityTags as $tagId) {
1082 $title[] = $allTags[$tagId];
1083 }
1084 $values[$index] = implode(', ', $title);
1085 $params[$index] = implode(',', $entityTags);
1086 }
1087 elseif ($name == 'activity_status_id') {
1088 $activityStatus = CRM_Core_PseudoConstant::activityStatus();
1089 $values[$index] = $activityStatus[$details->$name];
1090 $params[$index] = $details->$name;
1091 }
1092 elseif ($name == 'activity_date_time') {
1093 $values[$index] = CRM_Utils_Date::customFormat($details->$name);
1094 $params[$index] = $details->$name;
1095 }
1096 elseif ($name == 'contact_sub_type') {
1097 $contactSubTypeNames = explode(CRM_Core_DAO::VALUE_SEPARATOR, $details->$name);
1098 if (!empty($contactSubTypeNames)) {
1099 $contactSubTypeLabels = array();
1100 // get all contact subtypes
1101 $allContactSubTypes = CRM_Contact_BAO_ContactType::subTypeInfo();
1102 // build contact subtype labels array
1103 foreach ($contactSubTypeNames as $cstName) {
1104 if ($cstName) {
1105 $contactSubTypeLabels[] = $allContactSubTypes[$cstName]['label'];
1106 }
1107 }
1108 $values[$index] = implode(',', $contactSubTypeLabels);
1109 }
1110
1111 $params[$index] = $details->$name;
1112 }
1113 else {
1114 if (substr($name, 0, 7) === 'do_not_' || substr($name, 0, 3) === 'is_') {
1115 if ($details->$name) {
1116 $values[$index] = '[ x ]';
1117 }
1118 }
1119 else {
1120 if ($cfID = CRM_Core_BAO_CustomField::getKeyID($name)) {
1121 $htmlType = $field['html_type'];
1122
1123 // field_type is only set when we are retrieving profile values
1124 // when sending email, we call the same function to get custom field
1125 // values etc, i.e. emulating a profile
1126 $fieldType = CRM_Utils_Array::value('field_type', $field);
1127
1128 if ($htmlType == 'File') {
1129 $entityId = $cid;
1130 if (!$cid &&
1131 $fieldType == 'Activity' && !empty($componentWhere[0][2])
1132 ) {
1133 $entityId = $componentWhere[0][2];
1134 }
1135
1136 $fileURL = CRM_Core_BAO_CustomField::getFileURL($entityId,
1137 $cfID,
1138 NULL,
1139 $absolute,
1140 $additionalWhereClause
1141 );
1142 $params[$index] = $values[$index] = $fileURL['file_url'];
1143 }
1144 else {
1145 $customVal = NULL;
1146 if (isset($dao) && property_exists($dao, 'data_type') &&
1147 ($dao->data_type == 'Int' ||
1148 $dao->data_type == 'Boolean'
1149 )
1150 ) {
1151 $customVal = (int ) ($details->{$name});
1152 }
1153 elseif (isset($dao) && property_exists($dao, 'data_type')
1154 && $dao->data_type == 'Float'
1155 ) {
1156 $customVal = (float ) ($details->{$name});
1157 }
1158 elseif (!CRM_Utils_System::isNull(explode(CRM_Core_DAO::VALUE_SEPARATOR,
1159 $details->{$name}
1160 ))
1161 ) {
1162 $customVal = $details->{$name};
1163 }
1164
1165 //CRM-4582
1166 if (CRM_Utils_System::isNull($customVal)) {
1167 continue;
1168 }
1169
1170 $params[$index] = $customVal;
1171 $values[$index] = CRM_Core_BAO_CustomField::displayValue($customVal, $cfID);
1172 if ($field['data_type'] == 'ContactReference') {
1173 $params[$index] = $values[$index];
1174 }
1175 if (CRM_Core_DAO::getFieldValue('CRM_Core_DAO_CustomField',
1176 $cfID, 'is_search_range'
1177 )
1178 ) {
1179 $customFieldName = "{$name}_from";
1180 }
1181 }
1182 }
1183 elseif ($name == 'image_URL') {
1184 list($width, $height) = getimagesize(CRM_Utils_String::unstupifyUrl($details->$name));
1185 list($thumbWidth, $thumbHeight) = CRM_Contact_BAO_Contact::getThumbSize($width, $height);
1186
1187 $image_URL = '<img src="' . $details->$name . '" height= ' . $thumbHeight . ' width= ' . $thumbWidth . ' />';
1188 $values[$index] = "<a href='#' onclick='contactImagePopUp(\"{$details->$name}\", {$width}, {$height});'>{$image_URL}</a>";
1189 }
1190 elseif (in_array($name, array(
1191 'birth_date',
1192 'deceased_date',
1193 ))) {
1194 // @todo this set should be determined from metadata, not hard-coded.
1195 $values[$index] = CRM_Utils_Date::customFormat($details->$name);
1196 $params[$index] = CRM_Utils_Date::isoToMysql($details->$name);
1197 }
1198 else {
1199 $dao = '';
1200 if ($index == 'Campaign') {
1201 $dao = 'CRM_Campaign_DAO_Campaign';
1202 }
1203 elseif ($index == 'Contribution Page') {
1204 $dao = 'CRM_Contribute_DAO_ContributionPage';
1205 }
1206 if ($dao) {
1207 $value = CRM_Core_DAO::getFieldValue($dao, $details->$name, 'title');
1208 }
1209 else {
1210 $value = $details->$name;
1211 }
1212 $values[$index] = $value;
1213 }
1214 }
1215 }
1216 }
1217 elseif (strpos($name, '-') !== FALSE) {
1218 list($fieldName, $id, $type) = CRM_Utils_System::explode('-', $name, 3);
1219
1220 if (!in_array($fieldName, $multipleFields)) {
1221 if ($id == 'Primary') {
1222 // fix for CRM-1543
1223 // not sure why we'd every use Primary location type id
1224 // we need to fix the source if we are using it
1225 // $locationTypeName = CRM_Contact_BAO_Contact::getPrimaryLocationType( $cid );
1226 $locationTypeName = 1;
1227 }
1228 else {
1229 $locationTypeName = CRM_Utils_Array::value($id, $locationTypes);
1230 }
1231
1232 if (!$locationTypeName) {
1233 continue;
1234 }
1235
1236 $detailName = "{$locationTypeName}-{$fieldName}";
1237 $detailName = str_replace(' ', '_', $detailName);
1238
1239 if (in_array($fieldName, array(
1240 'phone',
1241 'im',
1242 'email',
1243 'openid',
1244 ))) {
1245 if ($type) {
1246 $detailName .= "-{$type}";
1247 }
1248 }
1249
1250 if (in_array($fieldName, array(
1251 'state_province',
1252 'country',
1253 'county',
1254 ))) {
1255 $values[$index] = $details->$detailName;
1256 $idx = $detailName . '_id';
1257 $params[$index] = $details->$idx;
1258 }
1259 elseif ($fieldName == 'im') {
1260 $providerId = $detailName . '-provider_id';
1261 if (isset($imProviders[$details->$providerId])) {
1262 $values[$index] = $details->$detailName . " (" . $imProviders[$details->$providerId] . ")";
1263 }
1264 else {
1265 $values[$index] = $details->$detailName;
1266 }
1267 $params[$index] = $details->$detailName;
1268 }
1269 elseif ($fieldName == 'phone') {
1270 $phoneExtField = str_replace('phone', 'phone_ext', $detailName);
1271 if (isset($details->$phoneExtField)) {
1272 $values[$index] = $details->$detailName . " (" . $details->$phoneExtField . ")";
1273 }
1274 else {
1275 $values[$index] = $details->$detailName;
1276 }
1277 $params[$index] = $details->$detailName;
1278 }
1279 else {
1280 $values[$index] = $params[$index] = $details->$detailName;
1281 }
1282 }
1283 else {
1284 $detailName = "website-{$id}-{$fieldName}";
1285 $url = CRM_Utils_System::fixURL($details->$detailName);
1286 if ($details->$detailName) {
1287 $websiteTypeId = "website-{$id}-website_type_id";
1288 $websiteType = $websiteTypes[$details->$websiteTypeId];
1289 $values[$index] = "<a href=\"$url\">{$details->$detailName} ( {$websiteType} )</a>";
1290 }
1291 else {
1292 $values[$index] = '';
1293 }
1294 }
1295 }
1296
1297 if ((CRM_Utils_Array::value('visibility', $field) == 'Public Pages and Listings') &&
1298 CRM_Core_Permission::check('profile listings and forms')
1299 ) {
1300
1301 if (CRM_Utils_System::isNull($params[$index])) {
1302 $params[$index] = $values[$index];
1303 }
1304 if (!isset($params[$index])) {
1305 continue;
1306 }
1307 if (!$customFieldName) {
1308 $fieldName = $field['name'];
1309 }
1310 else {
1311 $fieldName = $customFieldName;
1312 }
1313
1314 $url = NULL;
1315 if (CRM_Core_BAO_CustomField::getKeyID($field['name'])) {
1316 $htmlType = $field['html_type'];
1317 if ($htmlType == 'Link') {
1318 $url = $params[$index];
1319 }
1320 elseif (in_array($htmlType, array(
1321 'CheckBox',
1322 'Multi-Select',
1323 'AdvMulti-Select',
1324 'Multi-Select State/Province',
1325 'Multi-Select Country',
1326 ))) {
1327 $valSeperator = CRM_Core_DAO::VALUE_SEPARATOR;
1328 $selectedOptions = explode($valSeperator, $params[$index]);
1329
1330 foreach ($selectedOptions as $key => $multiOption) {
1331 if ($multiOption) {
1332 $url[] = CRM_Utils_System::url('civicrm/profile',
1333 'reset=1&force=1&gid=' . $field['group_id'] . '&' .
1334 urlencode($fieldName) .
1335 '=' .
1336 urlencode($multiOption)
1337 );
1338 }
1339 }
1340 }
1341 else {
1342 $url = CRM_Utils_System::url('civicrm/profile',
1343 'reset=1&force=1&gid=' . $field['group_id'] . '&' .
1344 urlencode($fieldName) .
1345 '=' .
1346 urlencode($params[$index])
1347 );
1348 }
1349 }
1350 else {
1351 $url = CRM_Utils_System::url('civicrm/profile',
1352 'reset=1&force=1&gid=' . $field['group_id'] . '&' .
1353 urlencode($fieldName) .
1354 '=' .
1355 urlencode($params[$index])
1356 );
1357 }
1358
1359 if ($url &&
1360 !empty($values[$index]) &&
1361 $searchable
1362 ) {
1363
1364 if (is_array($url) && !empty($url)) {
1365 $links = array();
1366 $eachMultiValue = explode(', ', $values[$index]);
1367 foreach ($eachMultiValue as $key => $valueLabel) {
1368 $links[] = '<a href="' . $url[$key] . '">' . $valueLabel . '</a>';
1369 }
1370 $values[$index] = implode(', ', $links);
1371 }
1372 else {
1373 $values[$index] = '<a href="' . $url . '">' . $values[$index] . '</a>';
1374 }
1375 }
1376 }
1377 }
1378 }
1379
1380 /**
1381 * Check if profile Group used by any module.
1382 *
1383 * @param int $id
1384 * Profile Id.
1385 *
1386 * @return bool
1387 *
1388 */
1389 public static function usedByModule($id) {
1390 //check whether this group is used by any module(check uf join records)
1391 $sql = "SELECT id
1392 FROM civicrm_uf_join
1393 WHERE civicrm_uf_join.uf_group_id=$id";
1394
1395 $dao = new CRM_Core_DAO();
1396 $dao->query($sql);
1397 if ($dao->fetch()) {
1398 return TRUE;
1399 }
1400 else {
1401 return FALSE;
1402 }
1403 }
1404
1405 /**
1406 * Delete the profile Group.
1407 *
1408 * @param int $id
1409 * Profile Id.
1410 *
1411 * @return bool
1412 *
1413 */
1414 public static function del($id) {
1415 //check whether this group contains any profile fields
1416 $profileField = new CRM_Core_DAO_UFField();
1417 $profileField->uf_group_id = $id;
1418 $profileField->find();
1419 while ($profileField->fetch()) {
1420 CRM_Core_BAO_UFField::del($profileField->id);
1421 }
1422
1423 //delete records from uf join table
1424 $ufJoin = new CRM_Core_DAO_UFJoin();
1425 $ufJoin->uf_group_id = $id;
1426 $ufJoin->delete();
1427
1428 //delete profile group
1429 $group = new CRM_Core_DAO_UFGroup();
1430 $group->id = $id;
1431 $group->delete();
1432 return 1;
1433 }
1434
1435 /**
1436 * Add the UF Group.
1437 *
1438 * @param array $params
1439 * Reference array contains the values submitted by the form.
1440 * @param array $ids
1441 * Reference array contains the id.
1442 *
1443 *
1444 * @return object
1445 */
1446 public static function add(&$params, $ids = array()) {
1447 $fields = array(
1448 'is_active',
1449 'add_captcha',
1450 'is_map',
1451 'is_update_dupe',
1452 'is_edit_link',
1453 'is_uf_link',
1454 'is_cms_user',
1455 );
1456 foreach ($fields as $field) {
1457 $params[$field] = CRM_Utils_Array::value($field, $params, FALSE);
1458 }
1459
1460 $params['limit_listings_group_id'] = CRM_Utils_Array::value('group', $params);
1461 $params['add_to_group_id'] = CRM_Utils_Array::value('add_contact_to_group', $params);
1462
1463 //CRM-15427
1464 if (!empty($params['group_type']) && is_array($params['group_type'])) {
1465 $params['group_type'] = implode(',', $params['group_type']);
1466 }
1467 $ufGroup = new CRM_Core_DAO_UFGroup();
1468 $ufGroup->copyValues($params);
1469
1470 $ufGroupID = CRM_Utils_Array::value('ufgroup', $ids, CRM_Utils_Array::value('id', $params));
1471 if (!$ufGroupID && empty($params['name'])) {
1472 $ufGroup->name = CRM_Utils_String::munge($ufGroup->title, '_', 56);
1473 }
1474 $ufGroup->id = $ufGroupID;
1475
1476 $ufGroup->save();
1477
1478 if (!$ufGroupID && empty($params['name'])) {
1479 $ufGroup->name = $ufGroup->name . "_{$ufGroup->id}";
1480 $ufGroup->save();
1481 }
1482
1483 return $ufGroup;
1484 }
1485
1486 /**
1487 * Make uf join entries for an uf group.
1488 *
1489 * @param array $params
1490 * (reference) an assoc array of name/value pairs.
1491 * @param int $ufGroupId
1492 * Ufgroup id.
1493 */
1494 public static function createUFJoin(&$params, $ufGroupId) {
1495 $groupTypes = CRM_Utils_Array::value('uf_group_type', $params);
1496
1497 // get ufjoin records for uf group
1498 $ufGroupRecord = CRM_Core_BAO_UFGroup::getUFJoinRecord($ufGroupId);
1499
1500 // get the list of all ufgroup types
1501 $allUFGroupType = CRM_Core_SelectValues::ufGroupTypes();
1502
1503 // this fix is done to prevent warning generated by array_key_exits incase of empty array is given as input
1504 if (!is_array($groupTypes)) {
1505 $groupTypes = array();
1506 }
1507
1508 // this fix is done to prevent warning generated by array_key_exits incase of empty array is given as input
1509 if (!is_array($ufGroupRecord)) {
1510 $ufGroupRecord = array();
1511 }
1512
1513 // check which values has to be inserted/deleted for contact
1514 $menuRebuild = FALSE;
1515 foreach ($allUFGroupType as $key => $value) {
1516 $joinParams = array();
1517 $joinParams['uf_group_id'] = $ufGroupId;
1518 $joinParams['module'] = $key;
1519 if ($key == 'User Account') {
1520 $menuRebuild = TRUE;
1521 }
1522 if (array_key_exists($key, $groupTypes) && !in_array($key, $ufGroupRecord)) {
1523 // insert a new record
1524 CRM_Core_BAO_UFGroup::addUFJoin($joinParams);
1525 }
1526 elseif (!array_key_exists($key, $groupTypes) && in_array($key, $ufGroupRecord)) {
1527 // delete a record for existing ufgroup
1528 CRM_Core_BAO_UFGroup::delUFJoin($joinParams);
1529 }
1530 }
1531
1532 //update the weight
1533 $query = "
1534 UPDATE civicrm_uf_join
1535 SET weight = %1
1536 WHERE uf_group_id = %2
1537 AND ( entity_id IS NULL OR entity_id <= 0 )
1538 ";
1539 $p = array(
1540 1 => array($params['weight'], 'Integer'),
1541 2 => array($ufGroupId, 'Integer'),
1542 );
1543 CRM_Core_DAO::executeQuery($query, $p);
1544
1545 // do a menu rebuild if we are on drupal, so it gets all the new menu entries
1546 // for user account
1547 $config = CRM_Core_Config::singleton();
1548 if ($menuRebuild &&
1549 $config->userSystem->is_drupal
1550 ) {
1551 menu_rebuild();
1552 }
1553 }
1554
1555 /**
1556 * Get the UF Join records for an ufgroup id.
1557 *
1558 * @param int $ufGroupId
1559 * Uf group id.
1560 * @param int $displayName
1561 * If set return display name in array.
1562 * @param int $status
1563 * If set return module other than default modules (User Account/User registration/Profile).
1564 *
1565 * @return array
1566 *
1567 */
1568 public static function getUFJoinRecord($ufGroupId = NULL, $displayName = NULL, $status = NULL) {
1569 if ($displayName) {
1570 $UFGroupType = array();
1571 $UFGroupType = CRM_Core_SelectValues::ufGroupTypes();
1572 }
1573
1574 $ufJoin = array();
1575 $dao = new CRM_Core_DAO_UFJoin();
1576
1577 if ($ufGroupId) {
1578 $dao->uf_group_id = $ufGroupId;
1579 }
1580
1581 $dao->find();
1582 $ufJoin = array();
1583
1584 while ($dao->fetch()) {
1585 if (!$displayName) {
1586 $ufJoin[$dao->id] = $dao->module;
1587 }
1588 else {
1589 if (isset($UFGroupType[$dao->module])) {
1590 // skip the default modules
1591 if (!$status) {
1592 $ufJoin[$dao->id] = $UFGroupType[$dao->module];
1593 }
1594 // added for CRM-1475
1595 }
1596 elseif (!CRM_Utils_Array::key($dao->module, $ufJoin)) {
1597 $ufJoin[$dao->id] = $dao->module;
1598 }
1599 }
1600 }
1601 return $ufJoin;
1602 }
1603
1604 /**
1605 * Function takes an associative array and creates a ufjoin record for ufgroup.
1606 *
1607 * @param array $params
1608 * (reference) an assoc array of name/value pairs.
1609 *
1610 * @return CRM_Core_BAO_UFJoin
1611 */
1612 public static function addUFJoin(&$params) {
1613 $ufJoin = new CRM_Core_DAO_UFJoin();
1614 $ufJoin->copyValues($params);
1615 $ufJoin->save();
1616 return $ufJoin;
1617 }
1618
1619 /**
1620 * Delete the uf join record for an uf group.
1621 *
1622 * @param array $params
1623 * (reference) an assoc array of name/value pairs.
1624 */
1625 public static function delUFJoin(&$params) {
1626 $ufJoin = new CRM_Core_DAO_UFJoin();
1627 $ufJoin->copyValues($params);
1628 $ufJoin->delete();
1629 }
1630
1631 /**
1632 * Get the weight for ufjoin record.
1633 *
1634 * @param int $ufGroupId
1635 * If $ufGroupId get update weight or add weight.
1636 *
1637 * @return int
1638 * weight of the UFGroup
1639 */
1640 public static function getWeight($ufGroupId = NULL) {
1641 //calculate the weight
1642 $p = array();
1643 if (!$ufGroupId) {
1644 $queryString = "SELECT ( MAX(civicrm_uf_join.weight)+1) as new_weight
1645 FROM civicrm_uf_join
1646 WHERE module = 'User Registration' OR module = 'User Account' OR module = 'Profile'";
1647 }
1648 else {
1649 $queryString = "SELECT MAX(civicrm_uf_join.weight) as new_weight
1650 FROM civicrm_uf_join
1651 WHERE civicrm_uf_join.uf_group_id = %1
1652 AND ( entity_id IS NULL OR entity_id <= 0 )";
1653 $p[1] = array($ufGroupId, 'Integer');
1654 }
1655
1656 $dao = CRM_Core_DAO::executeQuery($queryString, $p);
1657 $dao->fetch();
1658 return ($dao->new_weight) ? $dao->new_weight : 1;
1659 }
1660
1661 /**
1662 * Get the uf group for a module.
1663 *
1664 * @param string $moduleName
1665 * Module name.
1666 * @param int $count
1667 * No to increment the weight.
1668 * @param bool $skipPermission
1669 * @param int $op
1670 * Which operation (view, edit, create, etc) to check permission for.
1671 * @param array|NULL $returnFields list of UFGroup fields to return; NULL for default
1672 *
1673 * @return array
1674 * array of ufgroups for a module
1675 */
1676 public static function getModuleUFGroup($moduleName = NULL, $count = 0, $skipPermission = TRUE, $op = CRM_Core_Permission::VIEW, $returnFields = NULL) {
1677 $selectFields = array('id', 'title', 'created_id', 'is_active', 'is_reserved', 'group_type');
1678
1679 if (!CRM_Core_Config::isUpgradeMode()) {
1680 // CRM-13555, since description field was added later (4.4), and to avoid any problems with upgrade
1681 $selectFields[] = 'description';
1682 }
1683
1684 if (!empty($returnFields)) {
1685 $selectFields = array_merge($returnFields, array_diff($selectFields, $returnFields));
1686 }
1687
1688 $queryString = 'SELECT civicrm_uf_group.' . implode(', civicrm_uf_group.', $selectFields) . '
1689 FROM civicrm_uf_group
1690 LEFT JOIN civicrm_uf_join ON (civicrm_uf_group.id = uf_group_id)';
1691 $p = array();
1692 if ($moduleName) {
1693 $queryString .= ' AND civicrm_uf_group.is_active = 1
1694 WHERE civicrm_uf_join.module = %2';
1695 $p[2] = array($moduleName, 'String');
1696 }
1697
1698 // add permissioning for profiles only if not registration
1699 if (!$skipPermission) {
1700 $permissionClause = CRM_Core_Permission::ufGroupClause($op, 'civicrm_uf_group.');
1701 if (strpos($queryString, 'WHERE') !== FALSE) {
1702 $queryString .= " AND $permissionClause ";
1703 }
1704 else {
1705 $queryString .= " $permissionClause ";
1706 }
1707 }
1708
1709 $queryString .= ' ORDER BY civicrm_uf_join.weight, civicrm_uf_group.title';
1710 $dao = CRM_Core_DAO::executeQuery($queryString, $p);
1711
1712 $ufGroups = array();
1713 while ($dao->fetch()) {
1714 //skip mix profiles in user Registration / User Account
1715 if (($moduleName == 'User Registration' || $moduleName == 'User Account') &&
1716 CRM_Core_BAO_UFField::checkProfileType($dao->id)
1717 ) {
1718 continue;
1719 }
1720 foreach ($selectFields as $key => $field) {
1721 if ($field == 'id') {
1722 continue;
1723 }
1724 $ufGroups[$dao->id][$field] = $dao->$field;
1725 }
1726 }
1727
1728 // Allow other modules to alter/override the UFGroups.
1729 CRM_Utils_Hook::buildUFGroupsForModule($moduleName, $ufGroups);
1730
1731 return $ufGroups;
1732 }
1733
1734 /**
1735 * Filter ufgroups based on logged in user contact type.
1736 *
1737 * @param int $ufGroupId
1738 * Uf group id (profile id).
1739 * @param int $contactID
1740 *
1741 * @return bool
1742 * true or false
1743 */
1744 public static function filterUFGroups($ufGroupId, $contactID = NULL) {
1745 if (!$contactID) {
1746 $session = CRM_Core_Session::singleton();
1747 $contactID = $session->get('userID');
1748 }
1749
1750 if ($contactID) {
1751 //get the contact type
1752 $contactType = CRM_Contact_BAO_Contact::getContactType($contactID);
1753
1754 //match if exixting contact type is same as profile contact type
1755 $profileType = CRM_Core_BAO_UFField::getProfileType($ufGroupId);
1756
1757 if (CRM_Contact_BAO_ContactType::isaSubType($profileType)) {
1758 $profileType = CRM_Contact_BAO_ContactType::getBasicType($profileType);
1759 }
1760
1761 //allow special mix profiles for Contribution and Participant
1762 $specialProfiles = array('Contribution', 'Participant', 'Membership');
1763
1764 if (in_array($profileType, $specialProfiles)) {
1765 return TRUE;
1766 }
1767
1768 if (($contactType == $profileType) || $profileType == 'Contact') {
1769 return TRUE;
1770 }
1771 }
1772
1773 return FALSE;
1774 }
1775
1776 /**
1777 * Add profile field to a form.
1778 *
1779 * @param CRM_Core_Form $form
1780 * @param array $field
1781 * Properties.
1782 * @param int $mode
1783 * Profile mode.
1784 * @param int $contactId
1785 * @param bool $online
1786 * @param string $usedFor
1787 * For building up prefixed fieldname for special cases (e.g. onBehalf, Honor).
1788 * @param int $rowNumber
1789 * @param string $prefix
1790 *
1791 * @return null
1792 */
1793 public static function buildProfile(
1794 &$form,
1795 &$field,
1796 $mode,
1797 $contactId = NULL,
1798 $online = FALSE,
1799 $usedFor = NULL,
1800 $rowNumber = NULL,
1801 $prefix = ''
1802 ) {
1803 $defaultValues = array();
1804 $fieldName = $field['name'];
1805 $title = $field['title'];
1806 $attributes = $field['attributes'];
1807 $rule = $field['rule'];
1808 $view = $field['is_view'];
1809 $required = ($mode == CRM_Profile_Form::MODE_SEARCH) ? FALSE : $field['is_required'];
1810 $search = ($mode == CRM_Profile_Form::MODE_SEARCH) ? TRUE : FALSE;
1811 $isShared = CRM_Utils_Array::value('is_shared', $field, 0);
1812
1813 // do not display view fields in drupal registration form
1814 // CRM-4632
1815 if ($view && $mode == CRM_Profile_Form::MODE_REGISTER) {
1816 return NULL;
1817 }
1818
1819 if ($usedFor == 'onbehalf') {
1820 $name = "onbehalf[$fieldName]";
1821 }
1822 elseif ($usedFor == 'honor') {
1823 $name = "honor[$fieldName]";
1824 }
1825 elseif ($contactId && !$online) {
1826 $name = "field[$contactId][$fieldName]";
1827 }
1828 elseif ($rowNumber) {
1829 $name = "field[$rowNumber][$fieldName]";
1830 }
1831 elseif (!empty($prefix)) {
1832 $name = $prefix . "[$fieldName]";
1833 }
1834 else {
1835 $name = $fieldName;
1836 }
1837
1838 $selectAttributes = array('class' => 'crm-select2', 'placeholder' => TRUE);
1839
1840 if ($fieldName == 'image_URL' && $mode == CRM_Profile_Form::MODE_EDIT) {
1841 $deleteExtra = json_encode(ts('Are you sure you want to delete contact image.'));
1842 $deleteURL = array(
1843 CRM_Core_Action::DELETE => array(
1844 'name' => ts('Delete Contact Image'),
1845 'url' => 'civicrm/contact/image',
1846 'qs' => 'reset=1&id=%%id%%&gid=%%gid%%&action=delete',
1847 'extra' => 'onclick = "' . htmlspecialchars("if (confirm($deleteExtra)) this.href+='&confirmed=1'; else return false;") . '"',
1848 ),
1849 );
1850 $deleteURL = CRM_Core_Action::formLink($deleteURL,
1851 CRM_Core_Action::DELETE,
1852 array(
1853 'id' => $form->get('id'),
1854 'gid' => $form->get('gid'),
1855 ),
1856 ts('more'),
1857 FALSE,
1858 'contact.profileimage.delete',
1859 'Contact',
1860 $form->get('id')
1861 );
1862 $form->assign('deleteURL', $deleteURL);
1863 }
1864 $addressOptions = CRM_Core_BAO_Setting::valueOptions(CRM_Core_BAO_Setting::SYSTEM_PREFERENCES_NAME,
1865 'address_options', TRUE, NULL, TRUE
1866 );
1867
1868 if (substr($fieldName, 0, 14) === 'state_province') {
1869 $form->addChainSelect($name, array('label' => $title, 'required' => $required));
1870 $config = CRM_Core_Config::singleton();
1871 if (!in_array($mode, array(
1872 CRM_Profile_Form::MODE_EDIT,
1873 CRM_Profile_Form::MODE_SEARCH,
1874 )) &&
1875 $config->defaultContactStateProvince
1876 ) {
1877 $defaultValues[$name] = $config->defaultContactStateProvince;
1878 $form->setDefaults($defaultValues);
1879 }
1880 }
1881 elseif (substr($fieldName, 0, 7) === 'country') {
1882 $form->add('select', $name, $title, array('' => ts('- select -')) + CRM_Core_PseudoConstant::country(), $required, $selectAttributes);
1883 $config = CRM_Core_Config::singleton();
1884 if (!in_array($mode, array(
1885 CRM_Profile_Form::MODE_EDIT,
1886 CRM_Profile_Form::MODE_SEARCH,
1887 )) &&
1888 $config->defaultContactCountry
1889 ) {
1890 $defaultValues[$name] = $config->defaultContactCountry;
1891 $form->setDefaults($defaultValues);
1892 }
1893 }
1894 elseif (substr($fieldName, 0, 6) === 'county') {
1895 if ($addressOptions['county']) {
1896 $form->addChainSelect($name, array('label' => $title, 'required' => $required));
1897 }
1898 }
1899 elseif (substr($fieldName, 0, 9) === 'image_URL') {
1900 $form->add('file', $name, $title, $attributes, $required);
1901 $form->addUploadElement($name);
1902 }
1903 elseif (substr($fieldName, 0, 2) === 'im') {
1904 $form->add('text', $name, $title, $attributes, $required);
1905 if (!$contactId) {
1906 if ($usedFor) {
1907 if (substr($name, -1) == ']') {
1908 $providerName = substr($name, 0, -1) . '-provider_id]';
1909 }
1910 $form->add('select', $providerName, NULL,
1911 array(
1912 '' => ts('- select -'),
1913 ) + CRM_Core_PseudoConstant::get('CRM_Core_DAO_IM', 'provider_id'), $required
1914 );
1915 }
1916 else {
1917 $form->add('select', $name . '-provider_id', $title,
1918 array(
1919 '' => ts('- select -'),
1920 ) + CRM_Core_PseudoConstant::get('CRM_Core_DAO_IM', 'provider_id'), $required
1921 );
1922 }
1923
1924 if ($view && $mode != CRM_Profile_Form::MODE_SEARCH) {
1925 $form->freeze($name . '-provider_id');
1926 }
1927 }
1928 }
1929 elseif (CRM_Utils_Array::value('name', $field) == 'membership_type') {
1930 list($orgInfo, $types) = CRM_Member_BAO_MembershipType::getMembershipTypeInfo();
1931 $sel = &$form->addElement('hierselect', $name, $title);
1932 $select = array('' => ts('- select -'));
1933 if (count($orgInfo) == 1 && $field['is_required']) {
1934 // we only have one org - so we should default to it. Not sure about defaulting to first type
1935 // as it could be missed - so adding a select
1936 // however, possibly that is more similar to the membership form
1937 if (count($types[1]) > 1) {
1938 $types[1] = $select + $types[1];
1939 }
1940 }
1941 else {
1942 $orgInfo = $select + $orgInfo;
1943 }
1944 $sel->setOptions(array($orgInfo, $types));
1945 }
1946 elseif (CRM_Utils_Array::value('name', $field) == 'membership_status') {
1947 $form->add('select', $name, $title,
1948 array(
1949 '' => ts('- select -'),
1950 ) + CRM_Member_PseudoConstant::membershipStatus(NULL, NULL, 'label'), $required
1951 );
1952 }
1953 elseif (in_array($fieldName, array('gender_id', 'communication_style_id'))) {
1954 $options = array();
1955 $pseudoValues = CRM_Core_PseudoConstant::get('CRM_Contact_DAO_Contact', $fieldName);
1956 foreach ($pseudoValues as $key => $var) {
1957 $options[$key] = $form->createElement('radio', NULL, ts($title), $var, $key);
1958 }
1959 $group = $form->addGroup($options, $name, $title);
1960 if ($required) {
1961 $form->addRule($name, ts('%1 is a required field.', array(1 => $title)), 'required');
1962 }
1963 else {
1964 $group->setAttribute('allowClear', TRUE);
1965 }
1966 }
1967 elseif ($fieldName === 'prefix_id' || $fieldName === 'suffix_id') {
1968 $form->addSelect($name, array(
1969 'label' => $title,
1970 'entity' => 'contact',
1971 'field' => $fieldName,
1972 'class' => 'six',
1973 'placeholder' => '',
1974 ), $required);
1975 }
1976 elseif ($fieldName === 'contact_sub_type') {
1977 $gId = $form->get('gid') ? $form->get('gid') : CRM_Utils_Array::value('group_id', $field);
1978 if ($usedFor == 'onbehalf') {
1979 $profileType = 'Organization';
1980 }
1981 elseif ($usedFor == 'honor') {
1982 $profileType = CRM_Core_BAO_UFField::getProfileType($form->_params['honoree_profile_id']);
1983 }
1984 else {
1985 $profileType = $gId ? CRM_Core_BAO_UFField::getProfileType($gId) : NULL;
1986 if ($profileType == 'Contact') {
1987 $profileType = 'Individual';
1988 }
1989 }
1990
1991 $setSubtype = FALSE;
1992 if (CRM_Contact_BAO_ContactType::isaSubType($profileType)) {
1993 $setSubtype = $profileType;
1994 $profileType = CRM_Contact_BAO_ContactType::getBasicType($profileType);
1995 }
1996
1997 $subtypes = $profileType ? CRM_Contact_BAO_ContactType::subTypePairs($profileType) : array();
1998
1999 if ($setSubtype) {
2000 $subtypeList = array();
2001 $subtypeList[$setSubtype] = $subtypes[$setSubtype];
2002 }
2003 else {
2004 $subtypeList = $subtypes;
2005 }
2006
2007 $form->add('select', $name, $title, $subtypeList, $required, array('class' => 'crm-select2', 'multiple' => TRUE));
2008 }
2009 elseif (in_array($fieldName, CRM_Contact_BAO_Contact::$_greetingTypes)) {
2010 //add email greeting, postal greeting, addressee, CRM-4575
2011 $gId = $form->get('gid') ? $form->get('gid') : CRM_Utils_Array::value('group_id', $field);
2012 $profileType = CRM_Core_BAO_UFField::getProfileType($gId, TRUE, FALSE, TRUE);
2013
2014 if (empty($profileType) || in_array($profileType, array(
2015 'Contact',
2016 'Contribution',
2017 'Participant',
2018 'Membership',
2019 ))
2020 ) {
2021 $profileType = 'Individual';
2022 }
2023 if (CRM_Contact_BAO_ContactType::isaSubType($profileType)) {
2024 $profileType = CRM_Contact_BAO_ContactType::getBasicType($profileType);
2025 }
2026 $greeting = array(
2027 'contact_type' => $profileType,
2028 'greeting_type' => $fieldName,
2029 );
2030 $form->add('select', $name, $title,
2031 array(
2032 '' => ts('- select -'),
2033 ) + CRM_Core_PseudoConstant::greeting($greeting), $required
2034 );
2035 // add custom greeting element
2036 $form->add('text', $fieldName . '_custom', ts('Custom %1', array(1 => ucwords(str_replace('_', ' ', $fieldName)))),
2037 NULL, FALSE
2038 );
2039 }
2040 elseif ($fieldName === 'preferred_communication_method') {
2041 $communicationFields = CRM_Core_PseudoConstant::get('CRM_Contact_DAO_Contact', 'preferred_communication_method');
2042 foreach ($communicationFields as $key => $var) {
2043 if ($key == '') {
2044 continue;
2045 }
2046 $communicationOptions[] = $form->createElement('checkbox', $key, NULL, $var);
2047 }
2048 $form->addGroup($communicationOptions, $name, $title, '<br/>');
2049 }
2050 elseif ($fieldName === 'preferred_mail_format') {
2051 $form->add('select', $name, $title, CRM_Core_SelectValues::pmf());
2052 }
2053 elseif ($fieldName === 'preferred_language') {
2054 $form->add('select', $name, $title, array('' => ts('- select -')) + CRM_Contact_BAO_Contact::buildOptions('preferred_language'));
2055 }
2056 elseif ($fieldName == 'external_identifier') {
2057 $form->add('text', $name, $title, $attributes, $required);
2058 $contID = $contactId;
2059 if (!$contID) {
2060 $contID = $form->get('id');
2061 }
2062 $form->addRule($name,
2063 ts('External ID already exists in Database.'),
2064 'objectExists',
2065 array('CRM_Contact_DAO_Contact', $contID, 'external_identifier')
2066 );
2067 }
2068 elseif ($fieldName === 'group') {
2069 CRM_Contact_Form_Edit_TagsAndGroups::buildQuickForm($form, $contactId,
2070 CRM_Contact_Form_Edit_TagsAndGroups::GROUP,
2071 TRUE, $required,
2072 $title, NULL, $name
2073 );
2074 }
2075 elseif ($fieldName === 'tag') {
2076 CRM_Contact_Form_Edit_TagsAndGroups::buildQuickForm($form, $contactId,
2077 CRM_Contact_Form_Edit_TagsAndGroups::TAG,
2078 FALSE, $required,
2079 NULL, $title, $name
2080 );
2081 }
2082 elseif (substr($fieldName, 0, 4) === 'url-') {
2083 $form->add('text', $name, $title, CRM_Core_DAO::getAttribute('CRM_Core_DAO_Website', 'url'), $required);
2084 $form->addRule($name, ts('Enter a valid web address beginning with \'http://\' or \'https://\'.'), 'url');
2085 }
2086 // Note should be rendered as textarea
2087 elseif (substr($fieldName, -4) == 'note') {
2088 $form->add('textarea', $name, $title, $attributes, $required);
2089 }
2090 elseif (substr($fieldName, 0, 6) === 'custom') {
2091 $customFieldID = CRM_Core_BAO_CustomField::getKeyID($fieldName);
2092 if ($customFieldID) {
2093 CRM_Core_BAO_CustomField::addQuickFormElement($form, $name, $customFieldID, $required, $search, $title);
2094 }
2095 }
2096 elseif (substr($fieldName, 0, 14) === 'address_custom') {
2097 list($fName, $locTypeId) = CRM_Utils_System::explode('-', $fieldName, 2);
2098 $customFieldID = CRM_Core_BAO_CustomField::getKeyID(substr($fName, 8));
2099 if ($customFieldID) {
2100 CRM_Core_BAO_CustomField::addQuickFormElement($form, $name, $customFieldID, $required, $search, $title);
2101 }
2102 }
2103 elseif ($fieldName == 'send_receipt') {
2104 $form->addElement('checkbox', $name, $title);
2105 }
2106 elseif ($fieldName == 'soft_credit') {
2107 $form->addEntityRef("soft_credit_contact_id[$rowNumber]", ts('Soft Credit To'), array('create' => TRUE));
2108 $form->addMoney("soft_credit_amount[{$rowNumber}]", ts('Amount'), FALSE, NULL, FALSE);
2109 }
2110 elseif ($fieldName == 'product_name') {
2111 list($products, $options) = CRM_Contribute_BAO_Premium::getPremiumProductInfo();
2112 $sel = &$form->addElement('hierselect', $name, $title);
2113 $products = array(
2114 '0' => ts('- select -'),
2115 ) + $products;
2116 $sel->setOptions(array($products, $options));
2117 }
2118 elseif ($fieldName == 'payment_instrument') {
2119 $form->add('select', $name, $title,
2120 array('' => ts('- select -')) + CRM_Contribute_PseudoConstant::paymentInstrument(), $required);
2121 }
2122 elseif ($fieldName == 'financial_type') {
2123 $form->add('select', $name, $title,
2124 array(
2125 '' => ts('- select -'),
2126 ) + CRM_Contribute_PseudoConstant::financialType(), $required
2127 );
2128 }
2129 elseif ($fieldName == 'contribution_status_id') {
2130 $contributionStatuses = CRM_Contribute_PseudoConstant::contributionStatus();
2131 $statusName = CRM_Contribute_PseudoConstant::contributionStatus(NULL, 'name');
2132 foreach (array(
2133 'In Progress',
2134 'Overdue',
2135 'Refunded',
2136 ) as $suppress) {
2137 unset($contributionStatuses[CRM_Utils_Array::key($suppress, $statusName)]);
2138 }
2139
2140 $form->add('select', $name, $title,
2141 array(
2142 '' => ts('- select -'),
2143 ) + $contributionStatuses, $required
2144 );
2145 }
2146 elseif ($fieldName == 'soft_credit_type') {
2147 $name = "soft_credit_type[$rowNumber]";
2148 $form->add('select', $name, $title,
2149 array(
2150 '' => ts('- select -'),
2151 ) + CRM_Core_OptionGroup::values("soft_credit_type")
2152 );
2153 //CRM-15350: choose SCT field default value as 'Gift' for membership use
2154 //else (for contribution), use configured SCT default value
2155 $SCTDefaultValue = CRM_Core_OptionGroup::getDefaultValue("soft_credit_type");
2156 if ($field['field_type'] == 'Membership') {
2157 $SCTDefaultValue = CRM_Core_OptionGroup::getValue('soft_credit_type', 'Gift', 'name');
2158 }
2159 $form->addElement('hidden', 'sct_default_id', $SCTDefaultValue, array('id' => 'sct_default_id'));
2160 }
2161 elseif ($fieldName == 'contribution_soft_credit_pcp_id') {
2162 CRM_Contribute_Form_SoftCredit::addPCPFields($form, "[$rowNumber]");
2163 }
2164 elseif ($fieldName == 'currency') {
2165 $form->addCurrency($name, $title, $required, NULL, FALSE, FALSE);
2166 }
2167 elseif ($fieldName == 'contribution_page_id') {
2168 $form->add('select', $name, $title,
2169 array(
2170 '' => ts('- select -'),
2171 ) + CRM_Contribute_PseudoConstant::contributionPage(), $required, 'class="big"'
2172 );
2173 }
2174 elseif ($fieldName == 'activity_status_id') {
2175 $form->add('select', $name, $title,
2176 array(
2177 '' => ts('- select -'),
2178 ) + CRM_Core_PseudoConstant::activityStatus(), $required
2179 );
2180 }
2181 elseif ($fieldName == 'activity_engagement_level') {
2182 $form->add('select', $name, $title,
2183 array(
2184 '' => ts('- select -'),
2185 ) + CRM_Campaign_PseudoConstant::engagementLevel(), $required
2186 );
2187 }
2188 elseif ($fieldName == 'participant_status') {
2189 $cond = NULL;
2190 if ($online == TRUE) {
2191 $cond = 'visibility_id = 1';
2192 }
2193 $form->add('select', $name, $title,
2194 array(
2195 '' => ts('- select -'),
2196 ) + CRM_Event_PseudoConstant::participantStatus(NULL, $cond, 'label'), $required
2197 );
2198 }
2199 elseif ($fieldName == 'participant_role') {
2200 if (!empty($field['is_multiple'])) {
2201 $form->addCheckBox($name, $title, CRM_Event_PseudoConstant::participantRole(), NULL, NULL, NULL, NULL, '&nbsp', TRUE);
2202 }
2203 else {
2204 $form->add('select', $name, $title,
2205 array(
2206 '' => ts('- select -'),
2207 ) + CRM_Event_PseudoConstant::participantRole(), $required
2208 );
2209 }
2210 }
2211 elseif ($fieldName == 'world_region') {
2212 $form->add('select', $name, $title, CRM_Core_PseudoConstant::worldRegion(), $required, $selectAttributes);
2213 }
2214 elseif ($fieldName == 'signature_html') {
2215 $form->add('wysiwyg', $name, $title, CRM_Core_DAO::getAttribute('CRM_Core_DAO_Email', $fieldName));
2216 }
2217 elseif ($fieldName == 'signature_text') {
2218 $form->add('textarea', $name, $title, CRM_Core_DAO::getAttribute('CRM_Core_DAO_Email', $fieldName));
2219 }
2220 elseif (substr($fieldName, -11) == 'campaign_id') {
2221 if (CRM_Campaign_BAO_Campaign::isCampaignEnable()) {
2222 $campaigns = CRM_Campaign_BAO_Campaign::getCampaigns(CRM_Utils_Array::value($contactId,
2223 $form->_componentCampaigns
2224 ));
2225 $form->add('select', $name, $title,
2226 array(
2227 '' => ts('- select -'),
2228 ) + $campaigns, $required, 'class="crm-select2 big"'
2229 );
2230 }
2231 }
2232 elseif ($fieldName == 'activity_details') {
2233 $form->add('wysiwyg', $fieldName, $title, array('rows' => 4, 'cols' => 60), $required);
2234 }
2235 elseif ($fieldName == 'activity_duration') {
2236 $form->add('text', $name, $title, $attributes, $required);
2237 $form->addRule($name, ts('Please enter the duration as number of minutes (integers only).'), 'positiveInteger');
2238 }
2239 else {
2240 if (substr($fieldName, 0, 3) === 'is_' or substr($fieldName, 0, 7) === 'do_not_') {
2241 $form->add('advcheckbox', $name, $title, $attributes, $required);
2242 }
2243 elseif (CRM_Utils_Array::value('html_type', $field) === 'Select Date') {
2244 $extra = isset($field['datepicker']) ? $field['datepicker']['extra'] : CRM_Utils_Date::getDatePickerExtra($field);
2245 $attributes = isset($field['datepicker']) ? $field['datepicker']['attributes'] : CRM_Utils_Date::getDatePickerAttributes($field);
2246 $form->add('datepicker', $name, $title, $attributes, $required, $extra);
2247 }
2248 else {
2249 $form->add('text', $name, $title, $attributes, $required);
2250 }
2251 }
2252
2253 static $hiddenSubtype = FALSE;
2254 if (!$hiddenSubtype && CRM_Contact_BAO_ContactType::isaSubType($field['field_type'])) {
2255 // In registration mode params are submitted via POST and we don't have any clue
2256 // about profile-id or the profile-type (which could be a subtype)
2257 // To generalize the behavior and simplify the process,
2258 // lets always add the hidden
2259 //subtype value if there is any, and we won't have to
2260 // compute it while processing.
2261 if ($usedFor) {
2262 $form->addElement('hidden', $usedFor . '[contact_sub_type]', $field['field_type']);
2263 }
2264 else {
2265 $form->addElement('hidden', 'contact_sub_type_hidden', $field['field_type']);
2266 }
2267 $hiddenSubtype = TRUE;
2268 }
2269
2270 if (($view && $mode != CRM_Profile_Form::MODE_SEARCH) || $isShared) {
2271 $form->freeze($name);
2272 }
2273
2274 //add the rules
2275 if (in_array($fieldName, array(
2276 'non_deductible_amount',
2277 'total_amount',
2278 'fee_amount',
2279 'net_amount',
2280 ))) {
2281 $form->addRule($name, ts('Please enter a valid amount.'), 'money');
2282 }
2283 if ($rule) {
2284 if (!($rule == 'email' && $mode == CRM_Profile_Form::MODE_SEARCH)) {
2285 $form->addRule($name, ts('Please enter a valid %1', array(1 => $title)), $rule);
2286 }
2287 }
2288 }
2289
2290 /**
2291 * Set profile defaults.
2292 *
2293 * @param int $contactId
2294 * Contact id.
2295 * @param array $fields
2296 * Associative array of fields.
2297 * @param array $defaults
2298 * Defaults array.
2299 * @param bool $singleProfile
2300 * True for single profile else false(Update multiple items).
2301 * @param int $componentId
2302 * Id for specific components like contribute, event etc.
2303 * @param null $component
2304 */
2305 public static function setProfileDefaults(
2306 $contactId, &$fields, &$defaults,
2307 $singleProfile = TRUE, $componentId = NULL, $component = NULL
2308 ) {
2309 if (!$componentId) {
2310 //get the contact details
2311 list($contactDetails, $options) = CRM_Contact_BAO_Contact::getHierContactDetails($contactId, $fields);
2312 $details = CRM_Utils_Array::value($contactId, $contactDetails);
2313 $multipleFields = array('website' => 'url');
2314
2315 //start of code to set the default values
2316 foreach ($fields as $name => $field) {
2317 // skip pseudo fields
2318 if (substr($name, 0, 9) == 'phone_ext') {
2319 continue;
2320 }
2321
2322 //set the field name depending upon the profile mode(single/multiple)
2323 if ($singleProfile) {
2324 $fldName = $name;
2325 }
2326 else {
2327 $fldName = "field[$contactId][$name]";
2328 }
2329
2330 if ($name == 'group') {
2331 CRM_Contact_Form_Edit_TagsAndGroups::setDefaults($contactId, $defaults, CRM_Contact_Form_Edit_TagsAndGroups::GROUP, $fldName);
2332 }
2333 if ($name == 'tag') {
2334 CRM_Contact_Form_Edit_TagsAndGroups::setDefaults($contactId, $defaults, CRM_Contact_Form_Edit_TagsAndGroups::TAG, $fldName);
2335 }
2336
2337 if (!empty($details[$name]) || isset($details[$name])) {
2338 //to handle custom data (checkbox) to be written
2339 // to handle birth/deceased date, greeting_type and few other fields
2340 if (in_array($name, CRM_Contact_BAO_Contact::$_greetingTypes)) {
2341 $defaults[$fldName] = $details[$name . '_id'];
2342 $defaults[$name . '_custom'] = $details[$name . '_custom'];
2343 }
2344 elseif ($name == 'preferred_communication_method') {
2345 $v = explode(CRM_Core_DAO::VALUE_SEPARATOR, $details[$name]);
2346 foreach ($v as $item) {
2347 if ($item) {
2348 $defaults[$fldName . "[$item]"] = 1;
2349 }
2350 }
2351 }
2352 elseif ($name == 'contact_sub_type') {
2353 $defaults[$fldName] = explode(CRM_Core_DAO::VALUE_SEPARATOR, trim($details[$name], CRM_Core_DAO::VALUE_SEPARATOR));
2354 }
2355 elseif ($name == 'world_region') {
2356 $defaults[$fldName] = $details['worldregion_id'];
2357 }
2358 elseif ($customFieldId = CRM_Core_BAO_CustomField::getKeyID($name)) {
2359 // @todo retrieving the custom fields here seems obsolete - $field holds more data for the fields.
2360 $customFields = CRM_Core_BAO_CustomField::getFields(CRM_Utils_Array::value('contact_type', $details));
2361
2362 // hack to add custom data for components
2363 $components = array('Contribution', 'Participant', 'Membership', 'Activity');
2364 foreach ($components as $value) {
2365 $customFields = CRM_Utils_Array::crmArrayMerge($customFields,
2366 CRM_Core_BAO_CustomField::getFieldsForImport($value)
2367 );
2368 }
2369
2370 switch ($customFields[$customFieldId]['html_type']) {
2371 case 'Multi-Select State/Province':
2372 case 'Multi-Select Country':
2373 case 'AdvMulti-Select':
2374 case 'Multi-Select':
2375 $v = explode(CRM_Core_DAO::VALUE_SEPARATOR, $details[$name]);
2376 foreach ($v as $item) {
2377 if ($item) {
2378 $defaults[$fldName][$item] = $item;
2379 }
2380 }
2381 break;
2382
2383 case 'CheckBox':
2384 $v = explode(CRM_Core_DAO::VALUE_SEPARATOR, $details[$name]);
2385 foreach ($v as $item) {
2386 if ($item) {
2387 $defaults[$fldName][$item] = 1;
2388 // seems like we need this for QF style checkboxes in profile where its multiindexed
2389 // CRM-2969
2390 $defaults["{$fldName}[{$item}]"] = 1;
2391 }
2392 }
2393 break;
2394
2395 default:
2396 $defaults[$fldName] = $details[$name];
2397 break;
2398 }
2399 }
2400 else {
2401 $defaults[$fldName] = $details[$name];
2402 }
2403 }
2404 else {
2405 $blocks = array('email', 'phone', 'im', 'openid');
2406 list($fieldName, $locTypeId, $phoneTypeId) = CRM_Utils_System::explode('-', $name, 3);
2407 if (!in_array($fieldName, $multipleFields)) {
2408 if (is_array($details)) {
2409 foreach ($details as $key => $value) {
2410 // when we fixed CRM-5319 - get primary loc
2411 // type as per loc field and removed below code.
2412 $primaryLocationType = FALSE;
2413 if ($locTypeId == 'Primary') {
2414 if (is_array($value) && array_key_exists($fieldName, $value)) {
2415 $primaryLocationType = TRUE;
2416 if (in_array($fieldName, $blocks)) {
2417 $locTypeId = CRM_Contact_BAO_Contact::getPrimaryLocationType($contactId, FALSE, $fieldName);
2418 }
2419 else {
2420 $locTypeId = CRM_Contact_BAO_Contact::getPrimaryLocationType($contactId, FALSE, 'address');
2421 }
2422 }
2423 }
2424
2425 // fixed for CRM-665
2426 if (is_numeric($locTypeId)) {
2427 if ($primaryLocationType || $locTypeId == CRM_Utils_Array::value('location_type_id', $value)) {
2428 if (!empty($value[$fieldName])) {
2429 //to handle stateprovince and country
2430 if ($fieldName == 'state_province') {
2431 $defaults[$fldName] = $value['state_province_id'];
2432 }
2433 elseif ($fieldName == 'county') {
2434 $defaults[$fldName] = $value['county_id'];
2435 }
2436 elseif ($fieldName == 'country') {
2437 if (!isset($value['country_id']) || !$value['country_id']) {
2438 $config = CRM_Core_Config::singleton();
2439 if ($config->defaultContactCountry) {
2440 $defaults[$fldName] = $config->defaultContactCountry;
2441 }
2442 }
2443 else {
2444 $defaults[$fldName] = $value['country_id'];
2445 }
2446 }
2447 elseif ($fieldName == 'phone') {
2448 if ($phoneTypeId) {
2449 if (isset($value['phone'][$phoneTypeId])) {
2450 $defaults[$fldName] = $value['phone'][$phoneTypeId];
2451 }
2452 if (isset($value['phone_ext'][$phoneTypeId])) {
2453 $defaults[str_replace('phone', 'phone_ext', $fldName)] = $value['phone_ext'][$phoneTypeId];
2454 }
2455 }
2456 else {
2457 $phoneDefault = CRM_Utils_Array::value('phone', $value);
2458 // CRM-9216
2459 if (!is_array($phoneDefault)) {
2460 $defaults[$fldName] = $phoneDefault;
2461 }
2462 }
2463 }
2464 elseif ($fieldName == 'email') {
2465 //adding the first email (currently we don't support multiple emails of same location type)
2466 $defaults[$fldName] = $value['email'];
2467 }
2468 elseif ($fieldName == 'im') {
2469 //adding the first im (currently we don't support multiple ims of same location type)
2470 $defaults[$fldName] = $value['im'];
2471 $defaults[$fldName . '-provider_id'] = $value['im_provider_id'];
2472 }
2473 else {
2474 $defaults[$fldName] = $value[$fieldName];
2475 }
2476 }
2477 elseif (substr($fieldName, 0, 14) === 'address_custom' &&
2478 CRM_Utils_Array::value(substr($fieldName, 8), $value)
2479 ) {
2480 $defaults[$fldName] = $value[substr($fieldName, 8)];
2481 }
2482 }
2483 }
2484 }
2485 }
2486 }
2487 else {
2488 if (is_array($details)) {
2489 if ($fieldName === 'url'
2490 && !empty($details['website'])
2491 && !empty($details['website'][$locTypeId])
2492 ) {
2493 $defaults[$fldName] = CRM_Utils_Array::value('url', $details['website'][$locTypeId]);
2494 }
2495 }
2496 }
2497 }
2498 }
2499 }
2500
2501 //Handling Contribution Part of the batch profile
2502 if (CRM_Core_Permission::access('CiviContribute') && $component == 'Contribute') {
2503 self::setComponentDefaults($fields, $componentId, $component, $defaults);
2504 }
2505
2506 //Handling Event Participation Part of the batch profile
2507 if (CRM_Core_Permission::access('CiviEvent') && $component == 'Event') {
2508 self::setComponentDefaults($fields, $componentId, $component, $defaults);
2509 }
2510
2511 //Handling membership Part of the batch profile
2512 if (CRM_Core_Permission::access('CiviMember') && $component == 'Membership') {
2513 self::setComponentDefaults($fields, $componentId, $component, $defaults);
2514 }
2515
2516 //Handling Activity Part of the batch profile
2517 if ($component == 'Activity') {
2518 self::setComponentDefaults($fields, $componentId, $component, $defaults);
2519 }
2520 }
2521
2522 /**
2523 * Get profiles by type eg: pure Individual etc
2524 *
2525 * @param array $types
2526 * Associative array of types eg: types('Individual').
2527 * @param bool $onlyPure
2528 * True if only pure profiles are required.
2529 *
2530 * @return array
2531 * associative array of profiles
2532 */
2533 public static function getProfiles($types, $onlyPure = FALSE) {
2534 $profiles = array();
2535 $ufGroups = CRM_Core_PseudoConstant::get('CRM_Core_DAO_UFField', 'uf_group_id');
2536
2537 CRM_Utils_Hook::aclGroup(CRM_Core_Permission::ADMIN, NULL, 'civicrm_uf_group', $ufGroups, $ufGroups);
2538
2539 // Exclude Batch Data Entry profiles - CRM-10901
2540 $batchProfiles = CRM_Core_BAO_UFGroup::getBatchProfiles();
2541
2542 foreach ($ufGroups as $id => $title) {
2543 $ptype = CRM_Core_BAO_UFField::getProfileType($id, FALSE, $onlyPure);
2544 if (in_array($ptype, $types) && !array_key_exists($id, $batchProfiles)) {
2545 $profiles[$id] = $title;
2546 }
2547 }
2548 return $profiles;
2549 }
2550
2551 /**
2552 * Check whether a profile is valid combination of
2553 * required and/or optional profile types
2554 *
2555 * @param array $required
2556 * Array of types those are required.
2557 * @param array $optional
2558 * Array of types those are optional.
2559 *
2560 * @return array
2561 * associative array of profiles
2562 */
2563 public static function getValidProfiles($required, $optional = NULL) {
2564 if (!is_array($required) || empty($required)) {
2565 return NULL;
2566 }
2567
2568 $profiles = array();
2569 $ufGroups = CRM_Core_PseudoConstant::get('CRM_Core_DAO_UFField', 'uf_group_id');
2570
2571 CRM_Utils_Hook::aclGroup(CRM_Core_Permission::ADMIN, NULL, 'civicrm_uf_group', $ufGroups, $ufGroups);
2572
2573 foreach ($ufGroups as $id => $title) {
2574 $type = CRM_Core_BAO_UFField::checkValidProfileType($id, $required, $optional);
2575 if ($type) {
2576 $profiles[$id] = $title;
2577 }
2578 }
2579
2580 return $profiles;
2581 }
2582
2583 /**
2584 * Check whether a profile is valid combination of
2585 * required profile fields
2586 *
2587 * @param array $ufId
2588 * Integer id of the profile.
2589 * @param array $required
2590 * Array of fields those are required in the profile.
2591 *
2592 * @return array
2593 * associative array of profiles
2594 */
2595 public static function checkValidProfile($ufId, $required = NULL) {
2596 $validProfile = FALSE;
2597 if (!$ufId) {
2598 return $validProfile;
2599 }
2600
2601 if (!CRM_Core_DAO::getFieldValue('CRM_Core_DAO_UFGroup', $ufId, 'is_active')) {
2602 return $validProfile;
2603 }
2604
2605 $profileFields = self::getFields($ufId, FALSE, CRM_Core_Action::VIEW, NULL,
2606 NULL, FALSE, NULL, FALSE, NULL,
2607 CRM_Core_Permission::CREATE, NULL
2608 );
2609
2610 $validProfile = array();
2611 if (!empty($profileFields)) {
2612 $fields = array_keys($profileFields);
2613 foreach ($fields as $val) {
2614 foreach ($required as $key => $field) {
2615 if (strpos($val, $field) === 0) {
2616 unset($required[$key]);
2617 }
2618 }
2619 }
2620
2621 $validProfile = (empty($required)) ? TRUE : FALSE;
2622 }
2623
2624 return $validProfile;
2625 }
2626
2627 /**
2628 * Get default value for Register.
2629 *
2630 * @param array $fields
2631 * @param array $defaults
2632 *
2633 * @return array
2634 */
2635 public static function setRegisterDefaults(&$fields, &$defaults) {
2636 $config = CRM_Core_Config::singleton();
2637 foreach ($fields as $name => $field) {
2638 if (substr($name, 0, 8) == 'country-') {
2639 if (!empty($config->defaultContactCountry)) {
2640 $defaults[$name] = $config->defaultContactCountry;
2641 }
2642 }
2643 elseif (substr($name, 0, 15) == 'state_province-') {
2644 if (!empty($config->defaultContactStateProvince)) {
2645 $defaults[$name] = $config->defaultContactStateProvince;
2646 }
2647 }
2648 }
2649 return $defaults;
2650 }
2651
2652 /**
2653 * make a copy of a profile, including
2654 * all the fields in the profile
2655 *
2656 * @param int $id
2657 * The profile id to copy.
2658 *
2659 * @return \CRM_Core_DAO
2660 */
2661 public static function copy($id) {
2662 $maxId = CRM_Core_DAO::singleValueQuery("SELECT max(id) FROM civicrm_uf_group");
2663
2664 $title = ts('[Copy id %1]', array(1 => $maxId + 1));
2665 $fieldsFix = array(
2666 'suffix' => array(
2667 'title' => ' ' . $title,
2668 'name' => '__Copy_id_' . ($maxId + 1) . '_',
2669 ),
2670 );
2671
2672 $copy = &CRM_Core_DAO::copyGeneric('CRM_Core_DAO_UFGroup',
2673 array('id' => $id),
2674 NULL,
2675 $fieldsFix
2676 );
2677
2678 if ($pos = strrpos($copy->name, "_{$id}")) {
2679 $copy->name = substr_replace($copy->name, '', $pos);
2680 }
2681 $copy->name = CRM_Utils_String::munge($copy->name, '_', 56) . "_{$copy->id}";
2682 $copy->save();
2683
2684 $copyUFJoin = &CRM_Core_DAO::copyGeneric('CRM_Core_DAO_UFJoin',
2685 array('uf_group_id' => $id),
2686 array('uf_group_id' => $copy->id),
2687 NULL,
2688 'entity_table'
2689 );
2690
2691 $copyUFField = &CRM_Core_DAO::copyGeneric('CRM_Core_BAO_UFField',
2692 array('uf_group_id' => $id),
2693 array('uf_group_id' => $copy->id)
2694 );
2695
2696 $maxWeight = CRM_Utils_Weight::getMax('CRM_Core_DAO_UFJoin', NULL, 'weight');
2697
2698 //update the weight
2699 $query = "
2700 UPDATE civicrm_uf_join
2701 SET weight = %1
2702 WHERE uf_group_id = %2
2703 AND ( entity_id IS NULL OR entity_id <= 0 )
2704 ";
2705 $p = array(
2706 1 => array($maxWeight + 1, 'Integer'),
2707 2 => array($copy->id, 'Integer'),
2708 );
2709 CRM_Core_DAO::executeQuery($query, $p);
2710 if ($copy->is_reserved) {
2711 $query = "UPDATE civicrm_uf_group SET is_reserved = 0 WHERE id = %1";
2712 $params = array(1 => array($copy->id, 'Integer'));
2713 CRM_Core_DAO::executeQuery($query, $params);
2714 }
2715 CRM_Utils_Hook::copy('UFGroup', $copy);
2716
2717 return $copy;
2718 }
2719
2720 /**
2721 * Process that send notification e-mails
2722 *
2723 * @param int $contactID
2724 * Contact id.
2725 * @param array $values
2726 * Associative array of name/value pair.
2727 */
2728 public static function commonSendMail($contactID, &$values) {
2729 if (!$contactID || !$values) {
2730 return;
2731
2732 }
2733 $template = CRM_Core_Smarty::singleton();
2734
2735 $displayName = CRM_Core_DAO::getFieldValue('CRM_Contact_DAO_Contact',
2736 $contactID,
2737 'display_name'
2738 );
2739
2740 self::profileDisplay($values['id'], $values['values'], $template);
2741 $emailList = explode(',', $values['email']);
2742
2743 $contactLink = CRM_Utils_System::url('civicrm/contact/view',
2744 "reset=1&cid=$contactID",
2745 TRUE, NULL, FALSE, FALSE, TRUE
2746 );
2747
2748 //get the default domain email address.
2749 list($domainEmailName, $domainEmailAddress) = CRM_Core_BAO_Domain::getNameAndEmail();
2750
2751 if (!$domainEmailAddress || $domainEmailAddress == 'info@EXAMPLE.ORG') {
2752 $fixUrl = CRM_Utils_System::url('civicrm/admin/domain', 'action=update&reset=1');
2753 CRM_Core_Error::fatal(ts('The site administrator needs to enter a valid \'FROM Email Address\' in <a href="%1">Administer CiviCRM &raquo; Communications &raquo; FROM Email Addresses</a>. The email address used may need to be a valid mail account with your email service provider.', array(1 => $fixUrl)));
2754 }
2755
2756 foreach ($emailList as $emailTo) {
2757 // FIXME: take the below out of the foreach loop
2758 CRM_Core_BAO_MessageTemplate::sendTemplate(
2759 array(
2760 'groupName' => 'msg_tpl_workflow_uf',
2761 'valueName' => 'uf_notify',
2762 'contactId' => $contactID,
2763 'tplParams' => array(
2764 'displayName' => $displayName,
2765 'currentDate' => date('r'),
2766 'contactLink' => $contactLink,
2767 ),
2768 'from' => "$domainEmailName <$domainEmailAddress>",
2769 'toEmail' => $emailTo,
2770 )
2771 );
2772 }
2773 }
2774
2775 /**
2776 * Given a contact id and a group id, returns the field values from the db
2777 * for this group and notify email only if group's notify field is
2778 * set and field values are not empty
2779 *
2780 * @param int $gid
2781 * Group id.
2782 * @param int $cid
2783 * Contact id.
2784 * @param array $params
2785 * @param bool $skipCheck
2786 *
2787 * @return array
2788 */
2789 public function checkFieldsEmptyValues($gid, $cid, $params, $skipCheck = FALSE) {
2790 if ($gid) {
2791 if (CRM_Core_BAO_UFGroup::filterUFGroups($gid, $cid) || $skipCheck) {
2792 $values = array();
2793 $fields = CRM_Core_BAO_UFGroup::getFields($gid, FALSE, CRM_Core_Action::VIEW);
2794 CRM_Core_BAO_UFGroup::getValues($cid, $fields, $values, FALSE, $params, TRUE);
2795
2796 $email = CRM_Core_DAO::getFieldValue('CRM_Core_DAO_UFGroup', $gid, 'notify');
2797
2798 if (!empty($values) &&
2799 !empty($email)
2800 ) {
2801 $val = array(
2802 'id' => $gid,
2803 'values' => $values,
2804 'email' => $email,
2805 );
2806 return $val;
2807 }
2808 }
2809 }
2810 return NULL;
2811 }
2812
2813 /**
2814 * Assign uf fields to template.
2815 *
2816 * @param int $gid
2817 * Group id.
2818 * @param array $values
2819 * @param CRM_Core_Smarty $template
2820 */
2821 static public function profileDisplay($gid, $values, $template) {
2822 $groupTitle = CRM_Core_DAO::getFieldValue('CRM_Core_DAO_UFGroup', $gid, 'title');
2823 $template->assign('grouptitle', $groupTitle);
2824 if (count($values)) {
2825 $template->assign('values', $values);
2826 }
2827 }
2828
2829 /**
2830 * Format fields for dupe Contact Matching.
2831 *
2832 * @param array $params
2833 *
2834 * @param int $contactId
2835 *
2836 * @return array
2837 * associated formatted array
2838 */
2839 public static function formatFields($params, $contactId = NULL) {
2840 if ($contactId) {
2841 // get the primary location type id and email
2842 list($name, $primaryEmail, $primaryLocationType) = CRM_Contact_BAO_Contact_Location::getEmailDetails($contactId);
2843 }
2844 else {
2845 $defaultLocationType = CRM_Core_BAO_LocationType::getDefault();
2846 $primaryLocationType = $defaultLocationType->id;
2847 }
2848
2849 $data = array();
2850 $locationType = array();
2851 $count = 1;
2852 $primaryLocation = 0;
2853 foreach ($params as $key => $value) {
2854 list($fieldName, $locTypeId, $phoneTypeId) = explode('-', $key);
2855
2856 if ($locTypeId == 'Primary') {
2857 $locTypeId = $primaryLocationType;
2858 }
2859
2860 if (is_numeric($locTypeId)) {
2861 if (!in_array($locTypeId, $locationType)) {
2862 $locationType[$count] = $locTypeId;
2863 $count++;
2864 }
2865 $loc = CRM_Utils_Array::key($locTypeId, $locationType);
2866
2867 $data['location'][$loc]['location_type_id'] = $locTypeId;
2868
2869 // if we are getting in a new primary email, dont overwrite the new one
2870 if ($locTypeId == $primaryLocationType) {
2871 if (!empty($params['email-' . $primaryLocationType])) {
2872 $data['location'][$loc]['email'][$loc]['email'] = $fields['email-' . $primaryLocationType];
2873 }
2874 elseif (isset($primaryEmail)) {
2875 $data['location'][$loc]['email'][$loc]['email'] = $primaryEmail;
2876 }
2877 $primaryLocation++;
2878 }
2879
2880 if ($loc == 1) {
2881 $data['location'][$loc]['is_primary'] = 1;
2882 }
2883 if ($fieldName == 'phone') {
2884 if ($phoneTypeId) {
2885 $data['location'][$loc]['phone'][$loc]['phone_type_id'] = $phoneTypeId;
2886 }
2887 else {
2888 $data['location'][$loc]['phone'][$loc]['phone_type_id'] = '';
2889 }
2890 $data['location'][$loc]['phone'][$loc]['phone'] = $value;
2891 }
2892 elseif ($fieldName == 'email') {
2893 $data['location'][$loc]['email'][$loc]['email'] = $value;
2894 }
2895 elseif ($fieldName == 'im') {
2896 $data['location'][$loc]['im'][$loc]['name'] = $value;
2897 }
2898 else {
2899 if ($fieldName === 'state_province') {
2900 $data['location'][$loc]['address']['state_province_id'] = $value;
2901 }
2902 elseif ($fieldName === 'country') {
2903 $data['location'][$loc]['address']['country_id'] = $value;
2904 }
2905 else {
2906 $data['location'][$loc]['address'][$fieldName] = $value;
2907 }
2908 }
2909 }
2910 else {
2911 // TODO: prefix, suffix and gender translation may no longer be necessary - check inputs
2912 if ($key === 'individual_suffix') {
2913 $data['suffix_id'] = $value;
2914 }
2915 elseif ($key === 'individual_prefix') {
2916 $data['prefix_id'] = $value;
2917 }
2918 elseif ($key === 'gender') {
2919 $data['gender_id'] = $value;
2920 }
2921 elseif (substr($key, 0, 6) === 'custom') {
2922 if ($customFieldID = CRM_Core_BAO_CustomField::getKeyID($key)) {
2923 //fix checkbox
2924 if ($customFields[$customFieldID]['html_type'] == 'CheckBox') {
2925 $value = implode(CRM_Core_DAO::VALUE_SEPARATOR, array_keys($value));
2926 }
2927 // fix the date field
2928 if ($customFields[$customFieldID]['data_type'] == 'Date') {
2929 $date = CRM_Utils_Date::format($value);
2930 if (!$date) {
2931 $date = '';
2932 }
2933 $value = $date;
2934 }
2935
2936 $data['custom'][$customFieldID] = array(
2937 'id' => $id,
2938 'value' => $value,
2939 'extends' => $customFields[$customFieldID]['extends'],
2940 'type' => $customFields[$customFieldID]['data_type'],
2941 'custom_field_id' => $customFieldID,
2942 );
2943 }
2944 }
2945 elseif ($key == 'edit') {
2946 continue;
2947 }
2948 else {
2949 $data[$key] = $value;
2950 }
2951 }
2952 }
2953
2954 if (!$primaryLocation) {
2955 $loc++;
2956 $data['location'][$loc]['email'][$loc]['email'] = $primaryEmail;
2957 }
2958
2959 return $data;
2960 }
2961
2962 /**
2963 * Calculate the profile type 'group_type' as per profile fields.
2964 *
2965 * @param int $gId
2966 * Profile id.
2967 * @param bool $includeTypeValues
2968 * @param int $ignoreFieldId
2969 * Ignore particular profile field.
2970 *
2971 * @return array
2972 * list of calculated group type
2973 */
2974 public static function calculateGroupType($gId, $includeTypeValues = FALSE, $ignoreFieldId = NULL) {
2975 //get the profile fields.
2976 $ufFields = self::getFields($gId, FALSE, NULL, NULL, NULL, TRUE, NULL, TRUE);
2977 return self::_calculateGroupType($ufFields, $includeTypeValues, $ignoreFieldId);
2978 }
2979
2980 /**
2981 * Calculate the profile type 'group_type' as per profile fields.
2982 *
2983 * @param $ufFields
2984 * @param bool $includeTypeValues
2985 * @param int $ignoreFieldId
2986 * Ignore perticular profile field.
2987 *
2988 * @return array
2989 * list of calculated group type
2990 */
2991 public static function _calculateGroupType($ufFields, $includeTypeValues = FALSE, $ignoreFieldId = NULL) {
2992 $groupType = $groupTypeValues = $customFieldIds = array();
2993 if (!empty($ufFields)) {
2994 foreach ($ufFields as $fieldName => $fieldValue) {
2995 //ignore field from group type when provided.
2996 //in case of update profile field.
2997 if ($ignoreFieldId && ($ignoreFieldId == $fieldValue['field_id'])) {
2998 continue;
2999 }
3000 if (!in_array($fieldValue['field_type'], $groupType)) {
3001 $groupType[$fieldValue['field_type']] = $fieldValue['field_type'];
3002 }
3003
3004 if ($includeTypeValues && ($fldId = CRM_Core_BAO_CustomField::getKeyID($fieldName))) {
3005 $customFieldIds[$fldId] = $fldId;
3006 }
3007 }
3008 }
3009
3010 if (!empty($customFieldIds)) {
3011 $query = 'SELECT DISTINCT(cg.id), cg.extends, cg.extends_entity_column_id, cg.extends_entity_column_value FROM civicrm_custom_group cg LEFT JOIN civicrm_custom_field cf ON cf.custom_group_id = cg.id WHERE cg.extends_entity_column_value IS NOT NULL AND cf.id IN (' . implode(',', $customFieldIds) . ')';
3012
3013 $customGroups = CRM_Core_DAO::executeQuery($query);
3014 while ($customGroups->fetch()) {
3015 if (!$customGroups->extends_entity_column_value) {
3016 continue;
3017 }
3018
3019 $groupTypeName = "{$customGroups->extends}Type";
3020 if ($customGroups->extends == 'Participant' && $customGroups->extends_entity_column_id) {
3021 $groupTypeName = CRM_Core_OptionGroup::getValue('custom_data_type', $customGroups->extends_entity_column_id, 'value', 'String', 'name');
3022 }
3023
3024 foreach (explode(CRM_Core_DAO::VALUE_SEPARATOR, $customGroups->extends_entity_column_value) as $val) {
3025 if ($val) {
3026 $groupTypeValues[$groupTypeName][$val] = $val;
3027 }
3028 }
3029 }
3030
3031 if (!empty($groupTypeValues)) {
3032 $groupType = array_merge($groupType, $groupTypeValues);
3033 }
3034 }
3035
3036 return $groupType;
3037 }
3038
3039 /**
3040 * Update the profile type 'group_type' as per profile fields including group types and group subtype values.
3041 * Build and store string like: group_type1,group_type2[VALUE_SEPERATOR]group_type1Type:1:2:3,group_type2Type:1:2
3042 *
3043 * FIELDS GROUP_TYPE
3044 * BirthDate + Email Individual,Contact
3045 * BirthDate + Subject Individual,Activity
3046 * BirthDate + Subject + SurveyOnlyField Individual,Activity\0ActivityType:28
3047 * BirthDate + Subject + SurveyOnlyField + PhoneOnlyField (Not allowed)
3048 * BirthDate + SurveyOnlyField Individual,Activity\0ActivityType:28
3049 * BirthDate + Subject + SurveyOrPhoneField Individual,Activity\0ActivityType:2:28
3050 * BirthDate + SurveyOrPhoneField Individual,Activity\0ActivityType:2:28
3051 * BirthDate + SurveyOrPhoneField + SurveyOnlyField Individual,Activity\0ActivityType:2:28
3052 * BirthDate + StudentField + Subject + SurveyOnlyField Individual,Activity,Student\0ActivityType:28
3053 *
3054 * @param int $gId
3055 * @param array $groupTypes
3056 * With key having group type names.
3057 *
3058 * @return bool
3059 */
3060 public static function updateGroupTypes($gId, $groupTypes = array()) {
3061 if (!is_array($groupTypes) || !$gId) {
3062 return FALSE;
3063 }
3064
3065 // If empty group types set group_type as 'null'
3066 if (empty($groupTypes)) {
3067 return CRM_Core_DAO::setFieldValue('CRM_Core_DAO_UFGroup', $gId, 'group_type', 'null');
3068 }
3069
3070 $componentGroupTypes = array('Contribution', 'Participant', 'Membership', 'Activity', 'Case');
3071 $validGroupTypes = array_merge(array(
3072 'Contact',
3073 'Individual',
3074 'Organization',
3075 'Household',
3076 ), $componentGroupTypes, CRM_Contact_BAO_ContactType::subTypes());
3077
3078 $gTypes = $gTypeValues = array();
3079
3080 $participantExtends = array('ParticipantRole', 'ParticipantEventName', 'ParticipantEventType');
3081 // Get valid group type and group subtypes
3082 foreach ($groupTypes as $groupType => $value) {
3083 if (in_array($groupType, $validGroupTypes) && !in_array($groupType, $gTypes)) {
3084 $gTypes[] = $groupType;
3085 }
3086
3087 $subTypesOf = NULL;
3088
3089 if (in_array($groupType, $participantExtends)) {
3090 $subTypesOf = $groupType;
3091 }
3092 elseif (strpos($groupType, 'Type') > 0) {
3093 $subTypesOf = substr($groupType, 0, strpos($groupType, 'Type'));
3094 }
3095 else {
3096 continue;
3097 }
3098
3099 if (!empty($value) &&
3100 (in_array($subTypesOf, $componentGroupTypes) ||
3101 in_array($subTypesOf, $participantExtends)
3102 )
3103 ) {
3104 $gTypeValues[$subTypesOf] = $groupType . ":" . implode(':', $value);
3105 }
3106 }
3107
3108 if (empty($gTypes)) {
3109 return FALSE;
3110 }
3111
3112 // Build String to store group types and group subtypes
3113 $groupTypeString = implode(',', $gTypes);
3114 if (!empty($gTypeValues)) {
3115 $groupTypeString .= CRM_Core_DAO::VALUE_SEPARATOR . implode(',', $gTypeValues);
3116 }
3117
3118 return CRM_Core_DAO::setFieldValue('CRM_Core_DAO_UFGroup', $gId, 'group_type', $groupTypeString);
3119 }
3120
3121 /**
3122 * Create a "group_type" string.
3123 *
3124 * @param array $coreTypes
3125 * E.g. array('Individual','Contact','Student').
3126 * @param array $subTypes
3127 * E.g. array('ActivityType' => array(7, 11)).
3128 * @param string $delim
3129 *
3130 * @return string
3131 * @throws CRM_Core_Exception
3132 */
3133 public static function encodeGroupType($coreTypes, $subTypes, $delim = CRM_Core_DAO::VALUE_SEPARATOR) {
3134 $groupTypeExpr = '';
3135 if ($coreTypes) {
3136 $groupTypeExpr .= implode(',', $coreTypes);
3137 }
3138 if ($subTypes) {
3139 //CRM-15427 Allow Multiple subtype filtering
3140 //if (count($subTypes) > 1) {
3141 //throw new CRM_Core_Exception("Multiple subtype filtering is not currently supported by widget.");
3142 //}
3143 foreach ($subTypes as $subType => $subTypeIds) {
3144 $groupTypeExpr .= $delim . $subType . ':' . implode(':', $subTypeIds);
3145 }
3146 }
3147 return $groupTypeExpr;
3148 }
3149
3150 /**
3151 * setDefault componet specific profile fields.
3152 *
3153 * @param array $fields
3154 * Profile fields.
3155 * @param int $componentId
3156 * ComponetID.
3157 * @param string $component
3158 * Component name.
3159 * @param array $defaults
3160 * An array of default values.
3161 *
3162 * @param bool $isStandalone
3163 */
3164 public static function setComponentDefaults(&$fields, $componentId, $component, &$defaults, $isStandalone = FALSE) {
3165 if (!$componentId ||
3166 !in_array($component, array('Contribute', 'Membership', 'Event', 'Activity'))
3167 ) {
3168 return;
3169 }
3170
3171 $componentBAO = $componentSubType = NULL;
3172 switch ($component) {
3173 case 'Membership':
3174 $componentBAO = 'CRM_Member_BAO_Membership';
3175 $componentBAOName = 'Membership';
3176 $componentSubType = array('membership_type_id');
3177 break;
3178
3179 case 'Contribute':
3180 $componentBAO = 'CRM_Contribute_BAO_Contribution';
3181 $componentBAOName = 'Contribution';
3182 $componentSubType = array('financial_type_id');
3183 break;
3184
3185 case 'Event':
3186 $componentBAO = 'CRM_Event_BAO_Participant';
3187 $componentBAOName = 'Participant';
3188 $componentSubType = array('role_id', 'event_id', 'event_type_id');
3189 break;
3190
3191 case 'Activity':
3192 $componentBAO = 'CRM_Activity_BAO_Activity';
3193 $componentBAOName = 'Activity';
3194 $componentSubType = array('activity_type_id');
3195 break;
3196 }
3197
3198 $values = array();
3199 $params = array('id' => $componentId);
3200
3201 //get the component values.
3202 CRM_Core_DAO::commonRetrieve($componentBAO, $params, $values);
3203 if ($componentBAOName == 'Participant') {
3204 $values += array('event_type_id' => CRM_Core_DAO::getFieldValue('CRM_Event_DAO_Event', $values['event_id'], 'event_type_id'));
3205 }
3206
3207 $formattedGroupTree = array();
3208
3209 foreach ($fields as $name => $field) {
3210 $fldName = $isStandalone ? $name : "field[$componentId][$name]";
3211 if (array_key_exists($name, $values)) {
3212 $defaults[$fldName] = $values[$name];
3213 }
3214 elseif ($name == 'participant_note') {
3215 $noteDetails = CRM_Core_BAO_Note::getNote($componentId, 'civicrm_participant');
3216 $defaults[$fldName] = array_pop($noteDetails);
3217 }
3218 elseif (in_array($name, array(
3219 'financial_type',
3220 'payment_instrument',
3221 'participant_status',
3222 'participant_role',
3223 ))) {
3224 $defaults[$fldName] = $values["{$name}_id"];
3225 }
3226 elseif ($name == 'membership_type') {
3227 // since membership_type field is a hierselect -
3228 $defaults[$fldName][0]
3229 = CRM_Core_DAO::getFieldValue('CRM_Member_DAO_MembershipType', $values['membership_type_id'], 'member_of_contact_id', 'id');
3230 $defaults[$fldName][1] = $values['membership_type_id'];
3231 }
3232 elseif ($name == 'membership_status') {
3233 $defaults[$fldName] = $values['status_id'];
3234 }
3235 elseif (CRM_Core_BAO_CustomField::getKeyID($name, TRUE) !== array(NULL, NULL)) {
3236 if (empty($formattedGroupTree)) {
3237 //get the groupTree as per subTypes.
3238 $groupTree = array();
3239 foreach ($componentSubType as $subType) {
3240 $subTree = CRM_Core_BAO_CustomGroup::getTree($componentBAOName, CRM_Core_DAO::$_nullObject,
3241 $componentId, 0, $values[$subType]
3242 );
3243 $groupTree = CRM_Utils_Array::crmArrayMerge($groupTree, $subTree);
3244 }
3245 $formattedGroupTree = CRM_Core_BAO_CustomGroup::formatGroupTree($groupTree, 1);
3246 CRM_Core_BAO_CustomGroup::setDefaults($formattedGroupTree, $defaults);
3247 }
3248
3249 //FIX ME: We need to loop defaults, but once we move to custom_1_x convention this code can be simplified.
3250 foreach ($defaults as $customKey => $customValue) {
3251 if ($customFieldDetails = CRM_Core_BAO_CustomField::getKeyID($customKey, TRUE)) {
3252 if ($name == 'custom_' . $customFieldDetails[0]) {
3253
3254 //hack to set default for checkbox
3255 //basically this is for weired field name like field[33][custom_19]
3256 //we are converting this field name to array structure and assign value.
3257 $skipValue = FALSE;
3258
3259 foreach ($formattedGroupTree as $tree) {
3260 if (!empty($tree['fields'][$customFieldDetails[0]])) {
3261 if ('CheckBox' == CRM_Utils_Array::value('html_type', $tree['fields'][$customFieldDetails[0]])) {
3262 $skipValue = TRUE;
3263 $defaults['field'][$componentId][$name] = $customValue;
3264 break;
3265 }
3266 elseif (CRM_Utils_Array::value('data_type', $tree['fields'][$customFieldDetails[0]]) == 'Date') {
3267 $skipValue = TRUE;
3268
3269 // CRM-6681, $default contains formatted date, time values.
3270 $defaults[$fldName] = $customValue;
3271 if (!empty($defaults[$customKey . '_time'])) {
3272 $defaults['field'][$componentId][$name . '_time'] = $defaults[$customKey . '_time'];
3273 }
3274 }
3275 }
3276 }
3277
3278 if (!$skipValue || $isStandalone) {
3279 $defaults[$fldName] = $customValue;
3280 }
3281 unset($defaults[$customKey]);
3282 break;
3283 }
3284 }
3285 }
3286 }
3287 elseif (isset($values[$fldName])) {
3288 $defaults[$fldName] = $values[$fldName];
3289 }
3290 }
3291 }
3292
3293 /**
3294 * @param array|string $profiles - name of profile(s) to create links for
3295 * @param array $appendProfiles
3296 * Name of profile(s) to append to each link.
3297 *
3298 * @return array
3299 */
3300 public static function getCreateLinks($profiles = '', $appendProfiles = array()) {
3301 // Default to contact profiles
3302 if (!$profiles) {
3303 $profiles = array('new_individual', 'new_organization', 'new_household');
3304 }
3305 $profiles = (array) $profiles;
3306 $toGet = array_merge($profiles, (array) $appendProfiles);
3307 $retrieved = civicrm_api3('uf_group', 'get', array(
3308 'name' => array('IN' => $toGet),
3309 'is_active' => 1,
3310 ));
3311 $links = $append = array();
3312 if (!empty($retrieved['values'])) {
3313 foreach ($retrieved['values'] as $id => $profile) {
3314 if (in_array($profile['name'], $profiles)) {
3315 $links[] = array(
3316 'label' => $profile['title'],
3317 'url' => CRM_Utils_System::url('civicrm/profile/create', "reset=1&context=dialog&gid=$id",
3318 NULL, NULL, FALSE, FALSE, TRUE),
3319 'type' => ucfirst(str_replace('new_', '', $profile['name'])),
3320 );
3321 }
3322 else {
3323 $append[] = $id;
3324 }
3325 }
3326 foreach ($append as $id) {
3327 foreach ($links as &$link) {
3328 $link['url'] .= ",$id";
3329 }
3330 }
3331 }
3332 return $links;
3333 }
3334
3335 /**
3336 * Retrieve groups of profiles.
3337 *
3338 * @param int $profileID
3339 * Id of the profile.
3340 *
3341 * @return array
3342 * returns array
3343 */
3344 public static function profileGroups($profileID) {
3345 $groupTypes = array();
3346 $profileTypes = CRM_Core_DAO::getFieldValue('CRM_Core_DAO_UFGroup', $profileID, 'group_type');
3347 if ($profileTypes) {
3348 $groupTypeParts = explode(CRM_Core_DAO::VALUE_SEPARATOR, $profileTypes);
3349 $groupTypes = explode(',', $groupTypeParts[0]);
3350 }
3351 return $groupTypes;
3352 }
3353
3354 /**
3355 * Alter contact params by filtering existing subscribed groups and returns
3356 * unsubscribed groups array for subscription.
3357 *
3358 * @param array $params
3359 * Contact params.
3360 * @param int $contactId
3361 * User contact id.
3362 *
3363 * @return array
3364 * This contains array of groups for subscription
3365 */
3366 public static function getDoubleOptInGroupIds(&$params, $contactId = NULL) {
3367 $config = CRM_Core_Config::singleton();
3368 $subscribeGroupIds = array();
3369
3370 // process further only if profileDoubleOptIn enabled and if groups exist
3371 if (!array_key_exists('group', $params) ||
3372 !self::isProfileDoubleOptin() ||
3373 CRM_Utils_System::isNull($params['group'])
3374 ) {
3375 return $subscribeGroupIds;
3376 }
3377
3378 //check if contact email exist.
3379 $hasEmails = FALSE;
3380 foreach ($params as $name => $value) {
3381 if (strpos($name, 'email-') !== FALSE) {
3382 $hasEmails = TRUE;
3383 break;
3384 }
3385 }
3386
3387 //Proceed furthur only if email present
3388 if (!$hasEmails) {
3389 return $subscribeGroupIds;
3390 }
3391
3392 //do check for already subscriptions.
3393 $contactGroups = array();
3394 if ($contactId) {
3395 $query = "
3396 SELECT group_id
3397 FROM civicrm_group_contact
3398 WHERE status = 'Added'
3399 AND contact_id = %1";
3400
3401 $dao = CRM_Core_DAO::executeQuery($query, array(1 => array($contactId, 'Integer')));
3402 while ($dao->fetch()) {
3403 $contactGroups[$dao->group_id] = $dao->group_id;
3404 }
3405 }
3406
3407 //since we don't have names, compare w/ label.
3408 $mailingListGroupType = array_search('Mailing List', CRM_Core_OptionGroup::values('group_type'));
3409
3410 //actual processing start.
3411 foreach ($params['group'] as $groupId => $isSelected) {
3412 //unset group those are not selected.
3413 if (!$isSelected) {
3414 unset($params['group'][$groupId]);
3415 continue;
3416 }
3417
3418 $groupTypes = explode(CRM_Core_DAO::VALUE_SEPARATOR,
3419 CRM_Core_DAO::getFieldValue('CRM_Contact_DAO_Group', $groupId, 'group_type', 'id')
3420 );
3421 //get only mailing type group and unset it from params
3422 if (in_array($mailingListGroupType, $groupTypes) && !in_array($groupId, $contactGroups)) {
3423 $subscribeGroupIds[$groupId] = $groupId;
3424 unset($params['group'][$groupId]);
3425 }
3426 }
3427
3428 return $subscribeGroupIds;
3429 }
3430
3431 /**
3432 * Check if we are rendering mixed profiles.
3433 *
3434 * @param array $profileIds
3435 * Associated array of profile ids.
3436 *
3437 * @return bool
3438 * true if profile is mixed
3439 */
3440 public static function checkForMixProfiles($profileIds) {
3441 $mixProfile = FALSE;
3442
3443 $contactTypes = array('Individual', 'Household', 'Organization');
3444 $subTypes = CRM_Contact_BAO_ContactType::subTypes();
3445
3446 $components = array('Contribution', 'Participant', 'Membership', 'Activity');
3447
3448 $typeCount = array('ctype' => array(), 'subtype' => array());
3449 foreach ($profileIds as $gid) {
3450 $profileType = CRM_Core_BAO_UFField::getProfileType($gid);
3451 // ignore profile of type Contact
3452 if ($profileType == 'Contact') {
3453 continue;
3454 }
3455 if (in_array($profileType, $contactTypes)) {
3456 if (!isset($typeCount['ctype'][$profileType])) {
3457 $typeCount['ctype'][$profileType] = 1;
3458 }
3459
3460 // check if we are rendering profile of different contact types
3461 if (count($typeCount['ctype']) == 2) {
3462 $mixProfile = TRUE;
3463 break;
3464 }
3465 }
3466 elseif (in_array($profileType, $components)) {
3467 $mixProfile = TRUE;
3468 break;
3469 }
3470 else {
3471 if (!isset($typeCount['subtype'][$profileType])) {
3472 $typeCount['subtype'][$profileType] = 1;
3473 }
3474 // check if we are rendering profile of different contact sub types
3475 if (count($typeCount['subtype']) == 2) {
3476 $mixProfile = TRUE;
3477 break;
3478 }
3479 }
3480 }
3481 return $mixProfile;
3482 }
3483
3484 /**
3485 * Determine of we show overlay profile or not.
3486 *
3487 * @return bool
3488 * true if profile should be shown else false
3489 */
3490 public static function showOverlayProfile() {
3491 $showOverlay = TRUE;
3492
3493 // get the id of overlay profile
3494 $overlayProfileId = CRM_Core_DAO::getFieldValue('CRM_Core_DAO_UFGroup', 'summary_overlay', 'id', 'name');
3495 $query = "SELECT count(id) FROM civicrm_uf_field WHERE uf_group_id = {$overlayProfileId} AND visibility IN ('Public Pages', 'Public Pages and Listings') ";
3496
3497 $count = CRM_Core_DAO::singleValueQuery($query);
3498
3499 //check if there are no public fields and use is anonymous
3500 $session = CRM_Core_Session::singleton();
3501 if (!$count && !$session->get('userID')) {
3502 $showOverlay = FALSE;
3503 }
3504
3505 return $showOverlay;
3506 }
3507
3508 /**
3509 * Get group type values of the profile.
3510 *
3511 * @param int $profileId
3512 * @param string $groupType
3513 *
3514 * @return array
3515 * group type values
3516 */
3517 public static function groupTypeValues($profileId, $groupType = NULL) {
3518 $groupTypeValue = array();
3519 $groupTypes = CRM_Core_DAO::getFieldValue('CRM_Core_DAO_UFGroup', $profileId, 'group_type');
3520
3521 $groupTypeParts = explode(CRM_Core_DAO::VALUE_SEPARATOR, $groupTypes);
3522 if (empty($groupTypeParts[1])) {
3523 return $groupTypeValue;
3524 }
3525 $participantExtends = array('ParticipantRole', 'ParticipantEventName', 'ParticipantEventType');
3526
3527 foreach (explode(',', $groupTypeParts[1]) as $groupTypeValues) {
3528 $values = array();
3529 $valueParts = explode(':', $groupTypeValues);
3530 if ($groupType &&
3531 ($valueParts[0] != "{$groupType}Type" ||
3532 ($groupType == 'Participant' &&
3533 !in_array($valueParts[0], $participantExtends)
3534 )
3535 )
3536 ) {
3537 continue;
3538 }
3539 foreach ($valueParts as $val) {
3540 if (CRM_Utils_Rule::integer($val)) {
3541 $values[$val] = $val;
3542 }
3543 }
3544 if (!empty($values)) {
3545 $typeName = substr($valueParts[0], 0, -4);
3546 if (in_array($valueParts[0], $participantExtends)) {
3547 $typeName = $valueParts[0];
3548 }
3549 $groupTypeValue[$typeName] = $values;
3550 }
3551 }
3552
3553 return $groupTypeValue;
3554 }
3555
3556 /**
3557 * @return bool|object
3558 */
3559 public static function isProfileDoubleOptin() {
3560 // check for double optin
3561 $config = CRM_Core_Config::singleton();
3562 if (in_array('CiviMail', $config->enableComponents)) {
3563 return Civi::settings()->get('profile_double_optin');
3564 }
3565 return FALSE;
3566 }
3567
3568 /**
3569 * @return bool|object
3570 */
3571 public static function isProfileAddToGroupDoubleOptin() {
3572 // check for add to group double optin
3573 $config = CRM_Core_Config::singleton();
3574 if (in_array('CiviMail', $config->enableComponents)) {
3575 return Civi::settings()->get('profile_add_to_group_double_optin');
3576 }
3577 return FALSE;
3578 }
3579
3580 /**
3581 * Get profiles used for batch entry.
3582 *
3583 * @return array
3584 * profileIds profile ids
3585 */
3586 public static function getBatchProfiles() {
3587 $query = "SELECT id
3588 FROM civicrm_uf_group
3589 WHERE name IN ('contribution_batch_entry', 'membership_batch_entry')";
3590 $dao = CRM_Core_DAO::executeQuery($query);
3591 $profileIds = array();
3592 while ($dao->fetch()) {
3593 $profileIds[$dao->id] = $dao->id;
3594 }
3595 return $profileIds;
3596 }
3597
3598 /**
3599 * @todo what do I do?
3600 * @param $source
3601 * @param $destination
3602 * @param bool $returnMultiSummaryFields
3603 *
3604 * @return array|null
3605 */
3606 public static function shiftMultiRecordFields(&$source, &$destination, $returnMultiSummaryFields = FALSE) {
3607 $multiSummaryFields = $returnMultiSummaryFields ? array() : NULL;
3608 foreach ($source as $field => $properties) {
3609 if (!CRM_Core_BAO_CustomField::getKeyID($field)) {
3610 continue;
3611 }
3612 if (CRM_Core_BAO_CustomField::isMultiRecordField($field)) {
3613 $destination[$field] = $properties;
3614 if ($returnMultiSummaryFields) {
3615 if ($properties['is_multi_summary']) {
3616 $multiSummaryFields[$field] = $properties;
3617 }
3618 }
3619 unset($source[$field]);
3620 }
3621 }
3622 return $multiSummaryFields;
3623 }
3624
3625 /**
3626 * This is function is used to format pseudo fields.
3627 *
3628 * @param array $fields
3629 * Associated array of profile fields.
3630 *
3631 */
3632 public static function reformatProfileFields(&$fields) {
3633 //reformat fields array
3634 foreach ($fields as $name => $field) {
3635 //reformat phone and extension field
3636 if (substr($field['name'], 0, 13) == 'phone_and_ext') {
3637 $fieldSuffix = str_replace('phone_and_ext-', '', $field['name']);
3638
3639 // retain existing element properties and just update and replace key
3640 CRM_Utils_Array::crmReplaceKey($fields, $name, "phone-{$fieldSuffix}");
3641 $fields["phone-{$fieldSuffix}"]['name'] = "phone-{$fieldSuffix}";
3642 $fields["phone-{$fieldSuffix}"]['where'] = 'civicrm_phone.phone';
3643
3644 // add additional phone extension field
3645 $fields["phone_ext-{$fieldSuffix}"] = $field;
3646 $fields["phone_ext-{$fieldSuffix}"]['title'] = $field['title'] . ' - ' . ts('Ext.');
3647 $fields["phone_ext-{$fieldSuffix}"]['name'] = "phone_ext-{$fieldSuffix}";
3648 $fields["phone_ext-{$fieldSuffix}"]['where'] = 'civicrm_phone.phone_ext';
3649 $fields["phone_ext-{$fieldSuffix}"]['skipDisplay'] = 1;
3650 //ignore required for extension field
3651 $fields["phone_ext-{$fieldSuffix}"]['is_required'] = 0;
3652 }
3653 }
3654 }
3655
3656 }