CRM/Utils/Rule.php

   1 <?php
   2 /*
   3  +--------------------------------------------------------------------+
   4  | CiviCRM version 4.7                                                |
   5  +--------------------------------------------------------------------+
   6  | Copyright CiviCRM LLC (c) 2004-2017                                |
   7  +--------------------------------------------------------------------+
   8  | This file is a part of CiviCRM.                                    |
   9  |                                                                    |
  10  | CiviCRM is free software; you can copy, modify, and distribute it  |
  11  | under the terms of the GNU Affero General Public License           |
  12  | Version 3, 19 November 2007 and the CiviCRM Licensing Exception.   |
  13  |                                                                    |
  14  | CiviCRM is distributed in the hope that it will be useful, but     |
  15  | WITHOUT ANY WARRANTY; without even the implied warranty of         |
  16  | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.               |
  17  | See the GNU Affero General Public License for more details.        |
  18  |                                                                    |
  19  | You should have received a copy of the GNU Affero General Public   |
  20  | License and the CiviCRM Licensing Exception along                  |
  21  | with this program; if not, contact CiviCRM LLC                     |
  22  | at info[AT]civicrm[DOT]org. If you have questions about the        |
  23  | GNU Affero General Public License or the licensing of CiviCRM,     |
  24  | see the CiviCRM license FAQ at http://civicrm.org/licensing        |
  25  +--------------------------------------------------------------------+
  26  */
  27
  28 /**
  29  *
  30  * @package CRM
  31  * @copyright CiviCRM LLC (c) 2004-2017
  32  */
  33
  34 require_once 'HTML/QuickForm/Rule/Email.php';
  35
  36 /**
  37  * Class CRM_Utils_Rule
  38  */
  39 class CRM_Utils_Rule {
  40
  41   /**
  42    * @param $str
  43    * @param int $maxLength
  44    *
  45    * @return bool
  46    */
  47   public static function title($str, $maxLength = 127) {
  48
  49     // check length etc
  50     if (empty($str) || strlen($str) > $maxLength) {
  51       return FALSE;
  52     }
  53
  54     // Make sure it include valid characters, alpha numeric and underscores
  55     if (!preg_match('/^\w[\w\s\'\&\,\$\#\-\.\"\?\!]+$/i', $str)) {
  56       return FALSE;
  57     }
  58
  59     return TRUE;
  60   }
  61
  62   /**
  63    * @param $str
  64    *
  65    * @return bool
  66    */
  67   public static function longTitle($str) {
  68     return self::title($str, 255);
  69   }
  70
  71   /**
  72    * @param $str
  73    *
  74    * @return bool
  75    */
  76   public static function variable($str) {
  77     // check length etc
  78     if (empty($str) || strlen($str) > 31) {
  79       return FALSE;
  80     }
  81
  82     // make sure it includes valid characters, alpha numeric and underscores
  83     if (!preg_match('/^[\w]+$/i', $str)) {
  84       return FALSE;
  85     }
  86
  87     return TRUE;
  88   }
  89
  90   /**
  91    * Validate that a string is a valid MySQL column name or alias.
  92    *
  93    * @param $str
  94    *
  95    * @return bool
  96    */
  97   public static function mysqlColumnNameOrAlias($str) {
  98     // Check not empty.
  99     if (empty($str)) {
 100       return FALSE;
 101     }
 102
 103     // Ensure $str conforms to expected format. Not a complete expression of
 104     // what MySQL permits; this should permit the formats CiviCRM generates.
 105     //
 106     // * Table name prefix is optional.
 107     // * Table & column names & aliases:
 108     //   * Composed of alphanumeric chars, underscore and hyphens.
 109     //   * Maximum length of 64 chars.
 110     //   * Optionally surrounded by backticks, in which case spaces also OK.
 111     if (!preg_match('/^((`[\w- ]{1,64}`|[\w-]{1,64})\.)?(`[\w- ]{1,64}`|[\w-]{1,64})$/i', $str)) {
 112       return FALSE;
 113     }
 114
 115     return TRUE;
 116   }
 117
 118   /**
 119    * Validate that a string is ASC or DESC.
 120    *
 121    * Empty string should be treated as invalid and ignored => default = ASC.
 122    *
 123    * @param $str
 124    * @return bool
 125    */
 126   public static function mysqlOrderByDirection($str) {
 127     if (!preg_match('/^(asc|desc)$/i', $str)) {
 128       return FALSE;
 129     }
 130
 131     return TRUE;
 132   }
 133
 134   /**
 135    * Validate that a string is valid order by clause.
 136    *
 137    * @param $str
 138    * @return bool
 139    */
 140   public static function mysqlOrderBy($str) {
 141     $matches = array();
 142     // Using the field function in order by is valid.
 143     // Look for a string like field(contribution_status_id,3,4,6).
 144     // or field(civicrm_contribution.contribution_status_id,3,4,6)
 145     if (preg_match('/field\([a-z_.]+,[0-9,]+\)/', $str, $matches)) {
 146       // We have checked these. Remove them as they will fail the next lot.
 147       // Our check currently only permits numbers & no back ticks. If we get a
 148       // need for strings or backticks we can add.
 149       $str = str_replace($matches, '', $str);
 150     }
 151     $str = trim($str);
 152     if (!empty($matches) && empty($str)) {
 153       // nothing left to check after the field check.
 154       return TRUE;
 155     }
 156     // Making a regex for a comma separated list is quite hard and not readable
 157     // at all, so we split and loop over.
 158     $parts = explode(',', $str);
 159     foreach ($parts as $part) {
 160       if (!preg_match('/^((`[\w-]{1,64}`|[\w-]{1,64})\.)?(`[\w-]{1,64}`|[\w-]{1,64})( (asc|desc))?$/i', trim($part))) {
 161         return FALSE;
 162       }
 163     }
 164
 165     return TRUE;
 166   }
 167
 168   /**
 169    * @param $str
 170    *
 171    * @return bool
 172    */
 173   public static function qfVariable($str) {
 174     // check length etc
 175     //if ( empty( $str ) || strlen( $str ) > 31 ) {
 176     if (strlen(trim($str)) == 0 || strlen($str) > 31) {
 177       return FALSE;
 178     }
 179
 180     // make sure it includes valid characters, alpha numeric and underscores
 181     // added (. and ,) option (CRM-1336)
 182     if (!preg_match('/^[\w\s\.\,]+$/i', $str)) {
 183       return FALSE;
 184     }
 185
 186     return TRUE;
 187   }
 188
 189   /**
 190    * @param $phone
 191    *
 192    * @return bool
 193    */
 194   public static function phone($phone) {
 195     // check length etc
 196     if (empty($phone) || strlen($phone) > 16) {
 197       return FALSE;
 198     }
 199
 200     // make sure it includes valid characters, (, \s and numeric
 201     if (preg_match('/^[\d\(\)\-\.\s]+$/', $phone)) {
 202       return TRUE;
 203     }
 204     return FALSE;
 205   }
 206
 207   /**
 208    * @param $query
 209    *
 210    * @return bool
 211    */
 212   public static function query($query) {
 213     // check length etc
 214     if (empty($query) || strlen($query) < 3 || strlen($query) > 127) {
 215       return FALSE;
 216     }
 217
 218     // make sure it includes valid characters, alpha numeric and underscores
 219     if (!preg_match('/^[\w\s\%\'\&\,\$\#]+$/i', $query)) {
 220       return FALSE;
 221     }
 222
 223     return TRUE;
 224   }
 225
 226   /**
 227    * @param $url
 228    *
 229    * @return bool
 230    */
 231   public static function url($url) {
 232     if (preg_match('/^\//', $url)) {
 233       // allow relative URL's (CRM-15598)
 234       $url = 'http://' . $_SERVER['HTTP_HOST'] . $url;
 235     }
 236     return (bool) filter_var($url, FILTER_VALIDATE_URL);
 237   }
 238
 239   /**
 240    * @param $url
 241    *
 242    * @return bool
 243    */
 244   public static function urlish($url) {
 245     if (empty($url)) {
 246       return TRUE;
 247     }
 248     $url = Civi::paths()->getUrl($url, 'absolute');
 249     return (bool) filter_var($url, FILTER_VALIDATE_URL);
 250   }
 251
 252   /**
 253    * @param $string
 254    *
 255    * @return bool
 256    */
 257   public static function wikiURL($string) {
 258     $items = explode(' ', trim($string), 2);
 259     return self::url($items[0]);
 260   }
 261
 262   /**
 263    * @param $domain
 264    *
 265    * @return bool
 266    */
 267   public static function domain($domain) {
 268     // not perfect, but better than the previous one; see CRM-1502
 269     if (!preg_match('/^[A-Za-z0-9]([A-Za-z0-9\.\-]*[A-Za-z0-9])?$/', $domain)) {
 270       return FALSE;
 271     }
 272     return TRUE;
 273   }
 274
 275   /**
 276    * @param $value
 277    * @param null $default
 278    *
 279    * @return null
 280    */
 281   public static function date($value, $default = NULL) {
 282     if (is_string($value) &&
 283       preg_match('/^\d\d\d\d-?\d\d-?\d\d$/', $value)
 284     ) {
 285       return $value;
 286     }
 287     return $default;
 288   }
 289
 290   /**
 291    * @param $value
 292    * @param null $default
 293    *
 294    * @return null|string
 295    */
 296   public static function dateTime($value, $default = NULL) {
 297     $result = $default;
 298     if (is_string($value) &&
 299       preg_match('/^\d\d\d\d-?\d\d-?\d\d(\s\d\d:\d\d(:\d\d)?|\d\d\d\d(\d\d)?)?$/', $value)
 300     ) {
 301       $result = $value;
 302     }
 303
 304     return $result;
 305   }
 306
 307   /**
 308    * Check the validity of the date (in qf format)
 309    * note that only a year is valid, or a mon-year is
 310    * also valid in addition to day-mon-year. The date
 311    * specified has to be beyond today. (i.e today or later)
 312    *
 313    * @param array $date
 314    * @param bool $monthRequired
 315    *   Check whether month is mandatory.
 316    *
 317    * @return bool
 318    *   true if valid date
 319    */
 320   public static function currentDate($date, $monthRequired = TRUE) {
 321     $config = CRM_Core_Config::singleton();
 322
 323     $d = CRM_Utils_Array::value('d', $date);
 324     $m = CRM_Utils_Array::value('M', $date);
 325     $y = CRM_Utils_Array::value('Y', $date);
 326
 327     if (!$d && !$m && !$y) {
 328       return TRUE;
 329     }
 330
 331     // CRM-9017 CiviContribute/CiviMember form with expiration date format 'm Y'
 332     if (!$m && !empty($date['m'])) {
 333       $m = CRM_Utils_Array::value('m', $date);
 334     }
 335
 336     $day = $mon = 1;
 337     $year = 0;
 338     if ($d) {
 339       $day = $d;
 340     }
 341     if ($m) {
 342       $mon = $m;
 343     }
 344     if ($y) {
 345       $year = $y;
 346     }
 347
 348     // if we have day we need mon, and if we have mon we need year
 349     if (($d && !$m) ||
 350       ($d && !$y) ||
 351       ($m && !$y)
 352     ) {
 353       return FALSE;
 354     }
 355
 356     $result = FALSE;
 357     if (!empty($day) || !empty($mon) || !empty($year)) {
 358       $result = checkdate($mon, $day, $year);
 359     }
 360
 361     if (!$result) {
 362       return FALSE;
 363     }
 364
 365     // ensure we have month if required
 366     if ($monthRequired && !$m) {
 367       return FALSE;
 368     }
 369
 370     // now make sure this date is greater that today
 371     $currentDate = getdate();
 372     if ($year > $currentDate['year']) {
 373       return TRUE;
 374     }
 375     elseif ($year < $currentDate['year']) {
 376       return FALSE;
 377     }
 378
 379     if ($m) {
 380       if ($mon > $currentDate['mon']) {
 381         return TRUE;
 382       }
 383       elseif ($mon < $currentDate['mon']) {
 384         return FALSE;
 385       }
 386     }
 387
 388     if ($d) {
 389       if ($day > $currentDate['mday']) {
 390         return TRUE;
 391       }
 392       elseif ($day < $currentDate['mday']) {
 393         return FALSE;
 394       }
 395     }
 396
 397     return TRUE;
 398   }
 399
 400   /**
 401    * Check the validity of a date or datetime (timestamp)
 402    * value which is in YYYYMMDD or YYYYMMDDHHMMSS format
 403    *
 404    * Uses PHP checkdate() - params are ( int $month, int $day, int $year )
 405    *
 406    * @param string $date
 407    *
 408    * @return bool
 409    *   true if valid date
 410    */
 411   public static function mysqlDate($date) {
 412     // allow date to be null
 413     if ($date == NULL) {
 414       return TRUE;
 415     }
 416
 417     if (checkdate(substr($date, 4, 2), substr($date, 6, 2), substr($date, 0, 4))) {
 418       return TRUE;
 419     }
 420
 421     return FALSE;
 422   }
 423
 424   /**
 425    * @param $value
 426    *
 427    * @return bool
 428    */
 429   public static function integer($value) {
 430     if (is_int($value)) {
 431       return TRUE;
 432     }
 433
 434     // CRM-13460
 435     // ensure number passed is always a string numeral
 436     if (!is_numeric($value)) {
 437       return FALSE;
 438     }
 439
 440     // note that is_int matches only integer type
 441     // and not strings which are only integers
 442     // hence we do this here
 443     if (preg_match('/^\d+$/', $value)) {
 444       return TRUE;
 445     }
 446
 447     if ($value < 0) {
 448       $negValue = -1 * $value;
 449       if (is_int($negValue)) {
 450         return TRUE;
 451       }
 452     }
 453
 454     return FALSE;
 455   }
 456
 457   /**
 458    * @param $value
 459    *
 460    * @return bool
 461    */
 462   public static function positiveInteger($value) {
 463     if (is_int($value)) {
 464       return ($value < 0) ? FALSE : TRUE;
 465     }
 466
 467     // CRM-13460
 468     // ensure number passed is always a string numeral
 469     if (!is_numeric($value)) {
 470       return FALSE;
 471     }
 472
 473     if (preg_match('/^\d+$/', $value)) {
 474       return TRUE;
 475     }
 476
 477     return FALSE;
 478   }
 479
 480   /**
 481    * @param $value
 482    *
 483    * @return bool
 484    */
 485   public static function commaSeparatedIntegers($value) {
 486     foreach (explode(',', $value) as $val) {
 487       if (!self::positiveInteger($val)) {
 488         return FALSE;
 489       }
 490     }
 491     return TRUE;
 492   }
 493
 494   /**
 495    * @param $value
 496    *
 497    * @return bool
 498    */
 499   public static function numeric($value) {
 500     // lets use a php gatekeeper to ensure this is numeric
 501     if (!is_numeric($value)) {
 502       return FALSE;
 503     }
 504
 505     return preg_match('/(^-?\d\d*\.\d*$)|(^-?\d\d*$)|(^-?\.\d\d*$)/', $value) ? TRUE : FALSE;
 506   }
 507
 508   /**
 509    * @param $value
 510    * @param $noOfDigit
 511    *
 512    * @return bool
 513    */
 514   public static function numberOfDigit($value, $noOfDigit) {
 515     return preg_match('/^\d{' . $noOfDigit . '}$/', $value) ? TRUE : FALSE;
 516   }
 517
 518   /**
 519    * @param $value
 520    *
 521    * @return mixed
 522    */
 523   public static function cleanMoney($value) {
 524     // first remove all white space
 525     $value = str_replace(array(' ', "\t", "\n"), '', $value);
 526
 527     $config = CRM_Core_Config::singleton();
 528
 529     //CRM-14868
 530     $currencySymbols = CRM_Core_PseudoConstant::get(
 531       'CRM_Contribute_DAO_Contribution',
 532       'currency', array(
 533         'keyColumn' => 'name',
 534         'labelColumn' => 'symbol',
 535       )
 536     );
 537     $value = str_replace($currencySymbols, '', $value);
 538
 539     if ($config->monetaryThousandSeparator) {
 540       $mon_thousands_sep = $config->monetaryThousandSeparator;
 541     }
 542     else {
 543       $mon_thousands_sep = ',';
 544     }
 545
 546     // ugly fix for CRM-6391: do not drop the thousand separator if
 547     // it looks like it’s separating decimal part (because a given
 548     // value undergoes a second cleanMoney() call, for example)
 549     // CRM-15835 - in case the amount/value contains 0 after decimal
 550     // eg 150.5 the following if condition will pass
 551     if ($mon_thousands_sep != '.' or (substr($value, -3, 1) != '.' && substr($value, -2, 1) != '.')) {
 552       $value = str_replace($mon_thousands_sep, '', $value);
 553     }
 554
 555     if ($config->monetaryDecimalPoint) {
 556       $mon_decimal_point = $config->monetaryDecimalPoint;
 557     }
 558     else {
 559       $mon_decimal_point = '.';
 560     }
 561     $value = str_replace($mon_decimal_point, '.', $value);
 562
 563     return $value;
 564   }
 565
 566   /**
 567    * @param $value
 568    *
 569    * @return bool
 570    */
 571   public static function money($value) {
 572     $config = CRM_Core_Config::singleton();
 573
 574     // only edge case when we have a decimal point in the input money
 575     // field and not defined in the decimal Point in config settings
 576     if ($config->monetaryDecimalPoint &&
 577       $config->monetaryDecimalPoint != '.' &&
 578       // CRM-7122 also check for Thousands Separator in config settings
 579       $config->monetaryThousandSeparator != '.' &&
 580       substr_count($value, '.')
 581     ) {
 582       return FALSE;
 583     }
 584
 585     $value = self::cleanMoney($value);
 586
 587     if (self::integer($value)) {
 588       return TRUE;
 589     }
 590
 591     // Allow values such as -0, 1.024555, -.1
 592     // We need to support multiple decimal places here, not just the number allowed by locale
 593     //  otherwise tax calculations break when you want the inclusive amount to be a round number (eg. £10 inc. VAT requires 8.333333333 here).
 594     return preg_match('/(^-?\d+\.?\d*$)|(^-?\.\d+$)/', $value) ? TRUE : FALSE;
 595   }
 596
 597   /**
 598    * @param $value
 599    * @param int $maxLength
 600    *
 601    * @return bool
 602    */
 603   public static function string($value, $maxLength = 0) {
 604     if (is_string($value) &&
 605       ($maxLength === 0 || strlen($value) <= $maxLength)
 606     ) {
 607       return TRUE;
 608     }
 609     return FALSE;
 610   }
 611
 612   /**
 613    * @param $value
 614    *
 615    * @return bool
 616    */
 617   public static function boolean($value) {
 618     return preg_match(
 619       '/(^(1|0)$)|(^(Y(es)?|N(o)?)$)|(^(T(rue)?|F(alse)?)$)/i', $value
 620     ) ? TRUE : FALSE;
 621   }
 622
 623   /**
 624    * @param $value
 625    *
 626    * @return bool
 627    */
 628   public static function email($value) {
 629     return (bool) filter_var($value, FILTER_VALIDATE_EMAIL);
 630   }
 631
 632   /**
 633    * @param $list
 634    *
 635    * @return bool
 636    */
 637   public static function emailList($list) {
 638     $emails = explode(',', $list);
 639     foreach ($emails as $email) {
 640       $email = trim($email);
 641       if (!self::email($email)) {
 642         return FALSE;
 643       }
 644     }
 645     return TRUE;
 646   }
 647
 648   /**
 649    * allow between 4-6 digits as postal code since india needs 6 and US needs 5 (or
 650    * if u disregard the first 0, 4 (thanx excel!)
 651    * FIXME: we need to figure out how to localize such rules
 652    * @param $value
 653    *
 654    * @return bool
 655    */
 656   public static function postalCode($value) {
 657     if (preg_match('/^\d{4,6}(-\d{4})?$/', $value)) {
 658       return TRUE;
 659     }
 660     return FALSE;
 661   }
 662
 663   /**
 664    * See how file rules are written in HTML/QuickForm/file.php
 665    * Checks to make sure the uploaded file is ascii
 666    *
 667    * @param string $elementValue
 668    *
 669    * @return bool
 670    *   True if file has been uploaded, false otherwise
 671    */
 672   public static function asciiFile($elementValue) {
 673     if ((isset($elementValue['error']) && $elementValue['error'] == 0) ||
 674       (!empty($elementValue['tmp_name']) && $elementValue['tmp_name'] != 'none')
 675     ) {
 676       return CRM_Utils_File::isAscii($elementValue['tmp_name']);
 677     }
 678     return FALSE;
 679   }
 680
 681   /**
 682    * Checks to make sure the uploaded file is in UTF-8, recodes if it's not
 683    *
 684    * @param array $elementValue
 685    *
 686    * @return bool
 687    *   Whether file has been uploaded properly and is now in UTF-8.
 688    */
 689   public static function utf8File($elementValue) {
 690     $success = FALSE;
 691
 692     if ((isset($elementValue['error']) && $elementValue['error'] == 0) ||
 693       (!empty($elementValue['tmp_name']) && $elementValue['tmp_name'] != 'none')
 694     ) {
 695
 696       $success = CRM_Utils_File::isAscii($elementValue['tmp_name']);
 697
 698       // if it's a file, but not UTF-8, let's try and recode it
 699       // and then make sure it's an UTF-8 file in the end
 700       if (!$success) {
 701         $success = CRM_Utils_File::toUtf8($elementValue['tmp_name']);
 702         if ($success) {
 703           $success = CRM_Utils_File::isAscii($elementValue['tmp_name']);
 704         }
 705       }
 706     }
 707     return $success;
 708   }
 709
 710   /**
 711    * See how file rules are written in HTML/QuickForm/file.php
 712    * Checks to make sure the uploaded file is html
 713    *
 714    * @param array $elementValue
 715    *
 716    * @return bool
 717    *   True if file has been uploaded, false otherwise
 718    */
 719   public static function htmlFile($elementValue) {
 720     if ((isset($elementValue['error']) && $elementValue['error'] == 0) ||
 721       (!empty($elementValue['tmp_name']) && $elementValue['tmp_name'] != 'none')
 722     ) {
 723       return CRM_Utils_File::isHtmlFile($elementValue['tmp_name']);
 724     }
 725     return FALSE;
 726   }
 727
 728   /**
 729    * Check if there is a record with the same name in the db.
 730    *
 731    * @param string $value
 732    *   The value of the field we are checking.
 733    * @param array $options
 734    *   The daoName, fieldName (optional) and DomainID (optional).
 735    *
 736    * @return bool
 737    *   true if object exists
 738    */
 739   public static function objectExists($value, $options) {
 740     $name = 'name';
 741     if (isset($options[2])) {
 742       $name = $options[2];
 743     }
 744
 745     return CRM_Core_DAO::objectExists($value, CRM_Utils_Array::value(0, $options), CRM_Utils_Array::value(1, $options), CRM_Utils_Array::value(2, $options, $name), CRM_Utils_Array::value(3, $options));
 746   }
 747
 748   /**
 749    * @param $value
 750    * @param $options
 751    *
 752    * @return bool
 753    */
 754   public static function optionExists($value, $options) {
 755     return CRM_Core_OptionValue::optionExists($value, $options[0], $options[1], $options[2], CRM_Utils_Array::value(3, $options, 'name'), CRM_Utils_Array::value(4, $options, FALSE));
 756   }
 757
 758   /**
 759    * @param $value
 760    * @param $type
 761    *
 762    * @return bool
 763    */
 764   public static function creditCardNumber($value, $type) {
 765     return Validate_Finance_CreditCard::number($value, $type);
 766   }
 767
 768   /**
 769    * @param $value
 770    * @param $type
 771    *
 772    * @return bool
 773    */
 774   public static function cvv($value, $type) {
 775     return Validate_Finance_CreditCard::cvv($value, $type);
 776   }
 777
 778   /**
 779    * @param $value
 780    *
 781    * @return bool
 782    */
 783   public static function currencyCode($value) {
 784     static $currencyCodes = NULL;
 785     if (!$currencyCodes) {
 786       $currencyCodes = CRM_Core_PseudoConstant::currencyCode();
 787     }
 788     if (in_array($value, $currencyCodes)) {
 789       return TRUE;
 790     }
 791     return FALSE;
 792   }
 793
 794   /**
 795    * @param $value
 796    *
 797    * @return bool
 798    */
 799   public static function xssString($value) {
 800     if (is_string($value)) {
 801       return preg_match('!<(vb)?script[^>]*>.*</(vb)?script.*>!ims',
 802         $value
 803       ) ? FALSE : TRUE;
 804     }
 805     else {
 806       return TRUE;
 807     }
 808   }
 809
 810   /**
 811    * @param $path
 812    *
 813    * @return bool
 814    */
 815   public static function fileExists($path) {
 816     return file_exists($path);
 817   }
 818
 819   /**
 820    * Determine whether the value contains a valid reference to a directory.
 821    *
 822    * Paths stored in the setting system may be absolute -- or may be
 823    * relative to the default data directory.
 824    *
 825    * @param string $path
 826    * @return bool
 827    */
 828   public static function settingPath($path) {
 829     return is_dir(Civi::paths()->getPath($path));
 830   }
 831
 832   /**
 833    * @param $value
 834    * @param null $actualElementValue
 835    *
 836    * @return bool
 837    */
 838   public static function validContact($value, $actualElementValue = NULL) {
 839     if ($actualElementValue) {
 840       $value = $actualElementValue;
 841     }
 842
 843     return CRM_Utils_Rule::positiveInteger($value);
 844   }
 845
 846   /**
 847    * Check the validity of the date (in qf format)
 848    * note that only a year is valid, or a mon-year is
 849    * also valid in addition to day-mon-year
 850    *
 851    * @param array $date
 852    *
 853    * @return bool
 854    *   true if valid date
 855    */
 856   public static function qfDate($date) {
 857     $config = CRM_Core_Config::singleton();
 858
 859     $d = CRM_Utils_Array::value('d', $date);
 860     $m = CRM_Utils_Array::value('M', $date);
 861     $y = CRM_Utils_Array::value('Y', $date);
 862     if (isset($date['h']) ||
 863       isset($date['g'])
 864     ) {
 865       $m = CRM_Utils_Array::value('M', $date);
 866     }
 867
 868     if (!$d && !$m && !$y) {
 869       return TRUE;
 870     }
 871
 872     $day = $mon = 1;
 873     $year = 0;
 874     if ($d) {
 875       $day = $d;
 876     }
 877     if ($m) {
 878       $mon = $m;
 879     }
 880     if ($y) {
 881       $year = $y;
 882     }
 883
 884     // if we have day we need mon, and if we have mon we need year
 885     if (($d && !$m) ||
 886       ($d && !$y) ||
 887       ($m && !$y)
 888     ) {
 889       return FALSE;
 890     }
 891
 892     if (!empty($day) || !empty($mon) || !empty($year)) {
 893       return checkdate($mon, $day, $year);
 894     }
 895     return FALSE;
 896   }
 897
 898   /**
 899    * @param $key
 900    *
 901    * @return bool
 902    */
 903   public static function qfKey($key) {
 904     return ($key) ? CRM_Core_Key::valid($key) : FALSE;
 905   }
 906
 907   /**
 908    * Check if the values in the date range are in correct chronological order.
 909    *
 910    * @param array $fields
 911    *  Fields of the form.
 912    * @param $fieldName
 913    *  Name of date range field.
 914    * @param $errors
 915    *  The error array.
 916    * @param $title
 917    *  Title of the date range to be displayed in the error message.
 918    */
 919   public static function validDateRange($fields, $fieldName, &$errors, $title) {
 920     $lowDate = strtotime($fields[$fieldName . '_low']);
 921     $highDate = strtotime($fields[$fieldName . '_high']);
 922
 923     if ($lowDate > $highDate) {
 924       $errors[$fieldName . '_range_error'] = ts('%1: Please check that your date range is in correct chronological order.', array(1 => $title));
 925     }
 926   }
 927
 928   /**
 929    * @param string $key Extension Key to check
 930    * @return bool
 931    */
 932   public static function checkExtesnionKeyIsValid($key = NULL) {
 933     if (!empty($key) && !preg_match('/^[0-9a-zA-Z._-]+$/', $key)) {
 934       return FALSE;
 935     }
 936     return TRUE;
 937   }
 938
 939 }