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