[Summary view] [Print] [Text view]

   1  <?php
   2  /*+**********************************************************************************
   3   * The contents of this file are subject to the vtiger CRM Public License Version 1.0
   4   * ("License"); You may not use this file except in compliance with the License
   5   * The Original Code is:  vtiger CRM Open Source
   6   * The Initial Developer of the Original Code is vtiger.
   7   * Portions created by vtiger are Copyright (C) vtiger.
   8   * All Rights Reserved.
   9   ************************************************************************************/
  10  require_once ("include/Zend/Json.php");
  11  
  12  class VTJsonCondition {
  13  
  14  	function __construct() {
  15  
  16      }
  17  
  18  	function evaluate($condition, $entityCache, $id) {
  19          $expr = Zend_Json::decode($condition);
  20          $finalResult = TRUE;
  21          if (is_array($expr)) {
  22              $entityData = $entityCache->forId($id);
  23              $data = $entityData->getData();
  24  
  25              $groupResults = array();
  26              $expressionResults = array();
  27              $i = 0;
  28              foreach ($expr as $cond) {
  29                  $conditionGroup = $cond['groupid'];
  30                  if (empty($conditionGroup))
  31                      $conditionGroup = 0;
  32                  preg_match('/(\w+) : \((\w+)\) (\w+)/', $cond['fieldname'], $matches);
  33                  if (count($matches) == 0) {
  34                      $expressionResults[$conditionGroup][$i]['result'] = $this->checkCondition($entityData, $cond);
  35                  } else {
  36                      list($full, $referenceField, $referenceModule, $fieldname) = $matches;
  37                      $referenceFieldId = $data[$referenceField];
  38                      if ($referenceFieldId != 0) {
  39                          $entity = $entityCache->forId($data[$referenceField]);
  40                          if ($entity->getModuleName() == $referenceModule) {
  41                              $cond['fieldname'] = $fieldname;
  42                              $expressionResults[$conditionGroup][$i]['result'] = $this->checkCondition($entity, $cond, $entityData);
  43                          } else {
  44                              $expressionResults[$conditionGroup][$i]['result'] = FALSE;
  45                          }
  46                      } else {
  47                          $expressionResults[$conditionGroup][$i]['result'] = FALSE;
  48                      }
  49                  }
  50                  $expressionResults[$conditionGroup][$i + 1]['logicaloperator'] = (!empty($cond['joincondition'])) ? $cond['joincondition'] : 'and';
  51                  $groupResults[$conditionGroup]['logicaloperator'] = (!empty($cond['groupjoin'])) ? $cond['groupjoin'] : 'and';
  52                  $i++;
  53              }
  54  
  55              foreach ($expressionResults as $groupId => $groupExprResultSet) {
  56                  $groupResult = TRUE;
  57                  foreach ($groupExprResultSet as $exprResult) {
  58                      $result = $exprResult['result'];
  59                      $logicalOperator = $exprResult['logicaloperator'];
  60                      if (isset($result)) { // Condition to skip last condition
  61                          if (!empty($logicalOperator)) {
  62                              switch ($logicalOperator) {
  63                                  case 'and' : $groupResult = ($groupResult && $result);
  64                                      break;
  65                                  case 'or' : $groupResult = ($groupResult || $result);
  66                                      break;
  67                              }
  68                          } else { // Case for the first condition
  69                              $groupResult = $result;
  70                          }
  71                      }
  72                  }
  73                  $groupResults[$groupId]['result'] = $groupResult;
  74              }
  75  
  76              foreach ($groupResults as $groupId => $groupResult) {
  77                  $result = $groupResult['result'];
  78                  $logicalOperator = $groupResult['logicaloperator'];
  79                  if (isset($result)) { // Condition to skip last condition
  80                      if (!empty($logicalOperator)) {
  81                          switch ($logicalOperator) {
  82                              case 'and' : $finalResult = ($finalResult && $result);
  83                                  break;
  84                              case 'or' : $finalResult = ($finalResult || $result);
  85                                  break;
  86                          }
  87                      } else { // Case for the first condition
  88                          $finalResult = $result;
  89                      }
  90                  }
  91              }
  92          }
  93          return $finalResult;
  94      }
  95  
  96  	function startsWith($str, $subStr) {
  97          $sl = strlen($str);
  98          $ssl = strlen($subStr);
  99          if ($sl >= $ssl) {
 100              return substr_compare($str, $subStr, 0, $ssl) == 0;
 101          } else {
 102              return FALSE;
 103          }
 104      }
 105  
 106  	function endsWith($str, $subStr) {
 107          $sl = strlen($str);
 108          $ssl = strlen($subStr);
 109          if ($sl >= $ssl) {
 110              return substr_compare($str, $subStr, $sl - $ssl, $ssl) == 0;
 111          } else {
 112              return FALSE;
 113          }
 114      }
 115  
 116  	function checkCondition($entityData, $cond, $referredEntityData=null) {
 117          $data = $entityData->getData();
 118  
 119          $condition = $cond['operation'];
 120          if(empty($condition)) return false;
 121  
 122          $fieldValue = $data[$cond['fieldname']];
 123          $value = trim(html_entity_decode($cond['value']));
 124          $expressionType = $cond['valuetype'];
 125  
 126          if ($expressionType == 'fieldname') {
 127              if ($referredEntityData != null) {
 128                  $referredData = $referredEntityData->getData();
 129              } else {
 130                  $referredData = $data;
 131              }
 132              $value = $referredData[$value];
 133          } elseif ($expressionType == 'expression') {
 134              require_once  'modules/com_vtiger_workflow/expression_engine/include.inc';
 135  
 136              $parser = new VTExpressionParser(new VTExpressionSpaceFilter(new VTExpressionTokenizer($value)));
 137              $expression = $parser->expression();
 138              $exprEvaluater = new VTFieldExpressionEvaluater($expression);
 139              if ($referredEntityData != null) {
 140                  $value = $exprEvaluater->evaluate($referredEntityData);
 141              } else {
 142                  $value = $exprEvaluater->evaluate($entityData);
 143              }
 144          }
 145  
 146          global $current_user;
 147          $handler = vtws_getModuleHandlerFromName($entityData->getModuleName(), $current_user);
 148          $moduleFields = $handler->getMeta()->getModuleFields();
 149          $fieldInstance = $moduleFields[$cond['fieldname']];
 150  
 151          if($fieldInstance && $fieldInstance->getFieldDataType() == 'datetime') {
 152              //Convert the DB Date Time Format to User Date Time Format
 153              $date = new DateTimeField($fieldValue);
 154              $fieldValue = $date->getDisplayDateTimeValue();
 155              $valueArray = explode(' ', $value);
 156              if(count($valueArray) == 1) {
 157                  $fieldValueArray = explode(' ', $fieldValue);
 158                  $fieldValue = $fieldValueArray[0];
 159              }
 160          }
 161          //strtotime condition is added for days before, days after where we give integer values, so strtotime will return 0 for such cases.
 162          if($fieldInstance && $fieldInstance->getFieldDataType() == 'date' && $condition != 'between' && strtotime($value)) {
 163              //Convert User Date Format filter value to DB date format
 164              $value = getValidDBInsertDateValue($value);
 165          }
 166  
 167          if($fieldInstance && $fieldInstance->getFieldDataType() == 'time') {
 168              $value = $value.':00';    // time fields will not have seconds appended to it, so we are adding 
 169          }
 170          
 171          if($fieldInstance && $fieldInstance->getFieldDataType() == 'owner' ) { 
 172              if($condition == 'is' || $condition == 'is not') { 
 173                  //To avoid again checking whether it is user or not 
 174                  $idList = array();
 175                  $idList[] = vtws_getWebserviceEntityId('Users',$value); 
 176                  $idList[] = vtws_getWebserviceEntityId('Groups',$value);
 177                  $value = $idList;
 178                  $condition = ($condition == 'is') ? 'contains' : 'does not contain';
 179              } 
 180          }
 181  
 182          switch ($condition) {
 183              case "equal to":
 184                  return $fieldValue == $value;
 185              case "less than":
 186                  return $fieldValue < $value;
 187              case "greater than":
 188                  return $fieldValue > $value;
 189              case "does not equal":
 190                  return $fieldValue != $value;
 191              case "less than or equal to":
 192                  return $fieldValue <= $value;
 193              case "greater than or equal to":
 194                  return $fieldValue >= $value;
 195              case "is":
 196                  if (preg_match('/([^:]+):boolean$/', $value, $match)) {
 197                      $value = $match[1];
 198                      if ($value == 'true') {
 199                          return $fieldValue === 'on' || $fieldValue === 1 || $fieldValue === '1';
 200                      } else {
 201                          return $fieldValue === 'off' || $fieldValue === 0 || $fieldValue === '0' || $fieldValue === '';
 202                      }
 203                  } else {
 204                      return $fieldValue == $value;
 205                  }
 206              case "is not":
 207                  if (preg_match('/([^:]+):boolean$/', $value, $match)) {
 208                      $value = $match[1];
 209                      if ($value == 'true') {
 210                          return $fieldValue === 'off' || $fieldValue === 0 || $fieldValue === '0' || $fieldValue === '';
 211                      } else {
 212                          return $fieldValue === 'on' || $fieldValue === 1 || $fieldValue === '1';
 213                      }
 214                  } else {
 215                      return $fieldValue != $value;
 216                  }
 217              case "contains":
 218                  if(is_array($value)){ 
 219                      return in_array($fieldValue, $value); 
 220                  }
 221                  return strpos($fieldValue, $value) !== FALSE;
 222              case "does not contain":
 223                  if(empty($value)) unset($value);
 224                  if(is_array($value)){ 
 225                      return !in_array($fieldValue, $value); 
 226                  } 
 227                  return strpos($fieldValue, $value) === FALSE;
 228              case "starts with":
 229                  return $this->startsWith($fieldValue, $value);
 230              case "ends with":
 231                  return $this->endsWith($fieldValue, $value);
 232              case "matches":
 233                  return preg_match($value, $fieldValue);
 234  
 235              case "has changed" :
 236                  $entityDelta = new VTEntityDelta();
 237                  $idParts = vtws_getIdComponents($entityData->getId());
 238                  $hasChanged = $entityDelta->hasChanged($entityData->getModuleName(), $idParts[1], $cond['fieldname']);
 239                  if (empty($value)) {
 240                      return $hasChanged;
 241                  } else {
 242                      return $hasChanged && $fieldValue == $value;
 243                  }
 244              case "is empty":
 245                  if(empty($fieldValue)) {
 246                      return true;
 247                  }
 248                  return false;
 249              case "is not empty":
 250                  if(empty($fieldValue)) {
 251                      return false;
 252                  }
 253                  return true;
 254              case "before":
 255                  if(empty($fieldValue)) {
 256                      return false;
 257                  }
 258                  if($fieldValue < $value) {
 259                      return true;
 260                  }
 261                  return false;
 262              case "after":
 263                  if(empty($fieldValue)) {
 264                      return false;
 265                  }
 266                  if($fieldValue > $value) {
 267                      return true;
 268                  }
 269                  return false;
 270              case "between":
 271                  if(empty($fieldValue)) {
 272                      return false;
 273                  }
 274                  $values = explode(',', $value);
 275                  $values = array_map('getValidDBInsertDateValue',$values);
 276                  if($fieldValue > $values[0] && $fieldValue < $values[1]) {
 277                      return true;
 278                  }
 279                  return false;
 280              case 'is today':
 281                  $today = date('Y-m-d');
 282  
 283                  if($fieldValue == $today) {
 284                      return true;
 285                  }
 286                  return false;
 287              case 'less than days ago':
 288                  if(empty($fieldValue) || empty($value)) {
 289                      return false;
 290                  }
 291                  $today = date('Y-m-d');
 292                  $olderDate = date('Y-m-d', strtotime('-'.$value.' days'));
 293                  if($olderDate <= $fieldValue && $fieldValue <= $today) {
 294                      return true;
 295                  }
 296                  return false;
 297              case 'more than days ago':
 298                  if(empty($fieldValue) || empty($value)) {
 299                      return false;
 300                  }
 301                  $olderDate = date('Y-m-d', strtotime('-'.$value.' days'));
 302                  if($fieldValue <= $olderDate) {
 303                      return true;
 304                  }
 305                  return false;
 306              case 'in less than':
 307                  if(empty($fieldValue) || empty($value)) {
 308                      return false;
 309                  }
 310                  $today = date('Y-m-d');
 311                  $futureDate = date('Y-m-d', strtotime('+'.$value.' days'));
 312                  if($today <= $fieldValue && $fieldValue <= $futureDate) {
 313                      return true;
 314                  }
 315                  return false;
 316              case 'in more than':
 317                  if(empty($fieldValue) || empty($value)) {
 318                      return false;
 319                  }
 320                  $futureDate = date('Y-m-d', strtotime('+'.$value.' days'));
 321                  if($fieldValue >= $futureDate) {
 322                      return true;
 323                  }
 324                  return false;
 325              case 'days ago':
 326                  if(empty($fieldValue) || empty($value)) {
 327                      return false;
 328                  }
 329                  $olderDate = date('Y-m-d', strtotime('-'.$value.' days'));
 330                  if($fieldValue == $olderDate) {
 331                      return true;
 332                  }
 333                  return false;
 334              case 'days later':
 335                  if(empty($fieldValue) || empty($value)) {
 336                      return false;
 337                  }
 338                  $futureDate = date('Y-m-d', strtotime('+'.$value.' days'));
 339                  if($fieldValue == $futureDate) {
 340                      return true;
 341                  }
 342                  return false;
 343  
 344              case 'less than hours before':
 345                  if(empty($fieldValue) || empty($value)) {
 346                      return false;
 347                  }
 348                  $currentTime = date('Y-m-d H:i:s');
 349                  $olderDateTime = date('Y-m-d H:i:s', strtotime('-'.$value.' hours'));
 350                  if($olderDateTime <= $fieldValue && $fieldValue <= $currentTime) {
 351                      return true;
 352                  }
 353                  return false;
 354  
 355              case 'less than hours later':
 356                  if(empty($fieldValue) || empty($value)) {
 357                      return false;
 358                  }
 359                  $currentTime = date('Y-m-d H:i:s');
 360                  $futureDateTime = date('Y-m-d H:i:s', strtotime('+'.$value.' hours'));
 361                  if($currentTime <= $fieldValue && $fieldValue <= $futureDateTime) {
 362                      return true;
 363                  }
 364                  return false;
 365  
 366              case 'more than hours before':
 367                  if(empty($fieldValue) || empty($value)) {
 368                      return false;
 369                  }
 370                  $olderDateTime = date('Y-m-d H:i:s', strtotime('-'.$value.' hours'));
 371                  if($fieldValue <= $olderDateTime) {
 372                      return true;
 373                  }
 374                  return false;
 375              case 'more than hours later':
 376                  if(empty($fieldValue) || empty($value)) {
 377                      return false;
 378                  }
 379                  $futureDateTime = date('Y-m-d H:i:s', strtotime('+'.$value.' hours'));
 380                  if($fieldValue >= $futureDateTime) {
 381                      return true;
 382                  }
 383                  return false;
 384              case 'has changed to' :
 385                  $entityDelta = new VTEntityDelta();
 386                  $idParts = vtws_getIdComponents($entityData->getId());
 387                  return $entityDelta->hasChanged($entityData->getModuleName(), $idParts[1], $cond['fieldname'], $value);
 388              case 'is added':
 389                  //This condition was used only for comments. It should not execute from not from workflows, So it was always "FALSE"
 390                  return false;
 391              default:
 392                  //Unexpected condition
 393                  throw new Exception("Found an unexpected condition: " . $condition);
 394          }
 395      }
 396  
 397  }
 398  
 399  ?>