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