[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  
  11  /**
  12   * Profiles Record Model Class
  13   */
  14  class Settings_Profiles_Record_Model extends Settings_Vtiger_Record_Model {
  15  
  16      const PROFILE_FIELD_INACTIVE = 0;
  17      const PROFILE_FIELD_READONLY = 1;
  18      const PROFILE_FIELD_READWRITE = 2;
  19      private static $fieldLockedUiTypes = array('70');
  20  
  21      /**
  22       * Function to get the Id
  23       * @return <Number> Profile Id
  24       */
  25  	public function getId() {
  26          return $this->get('profileid');
  27      }
  28      /**
  29       * Function to get the Id
  30       * @return <Number> Profile Id
  31       */
  32  	protected function setId($id) {
  33          $this->set('profileid', $id);
  34          return $this;
  35      }
  36  
  37      /**
  38       * Function to get the Profile Name
  39       * @return <String>
  40       */
  41  	public function getName() {
  42          return $this->get('profilename');
  43      }
  44  
  45      /**
  46       * Function to get the description of the Profile
  47       * @return <String>
  48       */
  49  	public function getDescription() {
  50          return $this->get('description');
  51      }
  52  
  53      /**
  54       * Function to get the Edit View Url for the Profile
  55       * @return <String>
  56       */
  57  	public function getEditViewUrl() {
  58          return '?module=Profiles&parent=Settings&view=Edit&record='.$this->getId();
  59      }
  60  
  61      /**
  62       * Function to get the Edit View Url for the Profile
  63       * @return <String>
  64       */
  65  	public function getDuplicateViewUrl() {
  66          return '?module=Profiles&parent=Settings&view=Edit&from_record='.$this->getId();
  67      }
  68  
  69      /**
  70       * Function to get the Detail Action Url for the Profile
  71       * @return <String>
  72       */
  73  	public function getDeleteAjaxUrl() {
  74          return '?module=Profiles&parent=Settings&action=DeleteAjax&record='.$this->getId();
  75      }
  76  
  77      /**
  78       * Function to get the Delete Action Url for the current profile
  79       * @return <String>
  80       */
  81  	public function getDeleteActionUrl() {
  82          return 'index.php?module=Profiles&parent=Settings&view=DeleteAjax&record='.$this->getId();
  83      }
  84  
  85  	public function getGlobalPermissions() {
  86          $db = PearDatabase::getInstance();
  87  
  88          if(!$this->global_permissions) {
  89              $globalPermissions = array();
  90              $globalPermissions[Settings_Profiles_Module_Model::GLOBAL_ACTION_VIEW] =
  91                  $globalPermissions[Settings_Profiles_Module_Model::GLOBAL_ACTION_EDIT] =
  92                      Settings_Profiles_Module_Model::GLOBAL_ACTION_DEFAULT_VALUE;
  93  
  94              if($this->getId()) {
  95                  $sql = 'SELECT * FROM vtiger_profile2globalpermissions WHERE profileid=?';
  96                  $params = array($this->getId());
  97                  $result = $db->pquery($sql, $params);
  98                  $noOfRows = $db->num_rows($result);
  99                  for($i=0; $i<$noOfRows; ++$i) {
 100                      $actionId = $db->query_result($result, $i, 'globalactionid');
 101                      $permissionId = $db->query_result($result, $i, 'globalactionpermission');
 102                      $globalPermissions[$actionId] = $permissionId;
 103                  }
 104              }
 105              $this->global_permissions = $globalPermissions;
 106          }
 107          return $this->global_permissions;
 108      }
 109  
 110  	public function hasGlobalReadPermission() {
 111          $globalPermissions = $this->getGlobalPermissions();
 112          $viewAllPermission = $globalPermissions[Settings_Profiles_Module_Model::GLOBAL_ACTION_VIEW];
 113          if($viewAllPermission == Settings_Profiles_Module_Model::IS_PERMITTED_VALUE) {
 114              return true;
 115          }
 116          return false;
 117      }
 118  
 119  	public function hasGlobalWritePermission() {
 120          $globalPermissions = $this->getGlobalPermissions();
 121          $editAllPermission = $globalPermissions[Settings_Profiles_Module_Model::GLOBAL_ACTION_EDIT];
 122          if($this->hasGlobalReadPermission() &&
 123                  $editAllPermission == Settings_Profiles_Module_Model::IS_PERMITTED_VALUE) {
 124              return true;
 125          }
 126          return false;
 127  
 128      }
 129  
 130  	public function hasModulePermission($module) {
 131          $moduleModule = $this->getProfileTabModel($module);
 132          $modulePermissions = $moduleModule->get('permissions');
 133          $moduleAccessPermission = $modulePermissions['is_permitted'];
 134          if(isset($modulePermissions['is_permitted']) && $moduleAccessPermission == Settings_Profiles_Module_Model::IS_PERMITTED_VALUE) {
 135              return true;
 136          }
 137          return false;
 138      }
 139  
 140  	public function hasModuleActionPermission($module, $action) {
 141          $actionId = false;
 142          if(is_object($action) && is_a($action, 'Vtiger_Action_Model')) {
 143              $actionId = $action->getId();
 144          } else {
 145              $action = Vtiger_Action_Model::getInstance($action);
 146              $actionId = $action->getId();
 147          }
 148          if(!$actionId) {
 149              return false;
 150          }
 151  
 152          $moduleModel = $this->getProfileTabModel($module);
 153          $modulePermissions = $moduleModel->get('permissions');
 154          $moduleAccessPermission = $modulePermissions['is_permitted'];
 155          if($moduleAccessPermission != Settings_Profiles_Module_Model::IS_PERMITTED_VALUE) {
 156              return false;
 157          }
 158          $moduleActionPermissions = $modulePermissions['actions'];
 159          $moduleActionPermission = $moduleActionPermissions[$actionId];
 160          if(isset($moduleActionPermissions[$actionId]) && $moduleActionPermission == Settings_Profiles_Module_Model::IS_PERMITTED_VALUE) {
 161              return true;
 162          }
 163          return false;
 164      }
 165  
 166  	public function hasModuleFieldPermission($module, $field) {
 167          $fieldModel = $this->getProfileTabFieldModel($module, $field);
 168          $fieldPermissions = $fieldModel->get('permissions');
 169          $fieldAccessPermission = $fieldPermissions['visible'];
 170          if($fieldModel->isViewEnabled() && $fieldAccessPermission == Settings_Profiles_Module_Model::IS_PERMITTED_VALUE) {
 171              return true;
 172          }
 173          return false;
 174      }
 175  
 176  	public function hasModuleFieldWritePermission($module, $field) {
 177          $fieldModel = $this->getProfileTabFieldModel($module, $field);
 178          $fieldPermissions = $fieldModel->get('permissions');
 179          $fieldAccessPermission = $fieldPermissions['visible'];
 180          $fieldReadOnlyPermission = $fieldPermissions['readonly'];
 181          if($fieldModel->isEditEnabled()
 182                  && $fieldAccessPermission == Settings_Profiles_Module_Model::IS_PERMITTED_VALUE
 183                  && $fieldReadOnlyPermission == Settings_Profiles_Module_Model::IS_PERMITTED_VALUE) {
 184              return true;
 185          }
 186          return false;
 187      }
 188  
 189  	public function getModuleFieldPermissionValue($module, $field) {
 190          if(!$this->hasModuleFieldPermission($module, $field)) {
 191              return self::PROFILE_FIELD_INACTIVE;
 192          } elseif($this->hasModuleFieldWritePermission($module, $field)) {
 193              return self::PROFILE_FIELD_READWRITE;
 194          } else {
 195              return self::PROFILE_FIELD_READONLY;
 196          }
 197      }
 198  
 199  	public function isModuleFieldLocked($module, $field) {
 200          $fieldModel = $this->getProfileTabFieldModel($module, $field);
 201          if(!$fieldModel->isEditable() || $fieldModel->isMandatory()
 202                  || in_array($fieldModel->get('uitype'),self::$fieldLockedUiTypes)) {
 203              return true;
 204          }
 205          return false;
 206      }
 207  
 208  	public function getProfileTabModel($module) {
 209          $tabId = false;
 210          if(is_object($module) && is_a($module, 'Vtiger_Module_Model')) {
 211              $tabId = $module->getId();
 212          } else {
 213              $module = Vtiger_Module_Model::getInstance($module);
 214              $tabId = $module->getId();
 215          }
 216          if(!$tabId) {
 217              return false;
 218          }
 219          $allModulePermissions = $this->getModulePermissions();
 220          $moduleModel = $allModulePermissions[$tabId];
 221          return $moduleModel;
 222      }
 223  
 224  	public function getProfileTabFieldModel($module, $field) {
 225          $profileTabModel = $this->getProfileTabModel($module);
 226          $fieldId = false;
 227          if(is_object($field) && is_a($field, 'Vtiger_Field_Model')) {
 228              $fieldId = $field->getId();
 229          } else {
 230              $field = Vtiger_Field_Model::getInstance($field, $profileTabModel);
 231              $fieldId = $field->getId();
 232          }
 233          if(!$fieldId) {
 234              return false;
 235          }
 236          $moduleFields = $profileTabModel->getFields();
 237          $fieldModel = $moduleFields[$field->getName()];
 238          return $fieldModel;
 239      }
 240  
 241  	public function getProfileTabPermissions() {
 242          $db = PearDatabase::getInstance();
 243  
 244          if(!$this->profile_tab_permissions) {
 245              $profile2TabPermissions = array();
 246              if($this->getId()) {
 247                  $sql = 'SELECT * FROM vtiger_profile2tab WHERE profileid=?';
 248                  $params = array($this->getId());
 249                  $result = $db->pquery($sql, $params);
 250                  $noOfRows = $db->num_rows($result);
 251                  for($i=0; $i<$noOfRows; ++$i) {
 252                      $tabId = $db->query_result($result, $i, 'tabid');
 253                      $permissionId = $db->query_result($result, $i, 'permissions');
 254                      $profile2TabPermissions[$tabId] = $permissionId;
 255                  }
 256              }
 257              $this->profile_tab_permissions = $profile2TabPermissions;
 258          }
 259          return $this->profile_tab_permissions;
 260      }
 261  
 262  	public function getProfileTabFieldPermissions($tabId) {
 263          $db = PearDatabase::getInstance();
 264  
 265          if(!$this->profile_tab_field_permissions[$tabId]) {
 266              $profile2TabFieldPermissions = array();
 267              if($this->getId()) {
 268                  $sql = 'SELECT * FROM vtiger_profile2field WHERE profileid=? AND tabid=?';
 269                  $params = array($this->getId(), $tabId);
 270                  $result = $db->pquery($sql, $params);
 271                  $noOfRows = $db->num_rows($result);
 272                  for($i=0; $i<$noOfRows; ++$i) {
 273                      $fieldId = $db->query_result($result, $i, 'fieldid');
 274                      $visible = $db->query_result($result, $i, 'visible');
 275                      $readOnly = $db->query_result($result, $i, 'readonly');
 276                      $profile2TabFieldPermissions[$fieldId]['visible'] = $visible;
 277                      $profile2TabFieldPermissions[$fieldId]['readonly'] = $readOnly;
 278                  }
 279              }
 280              $this->profile_tab_field_permissions[$tabId] = $profile2TabFieldPermissions;
 281          }
 282          return $this->profile_tab_field_permissions[$tabId];
 283      }
 284  
 285  	public function getProfileActionPermissions() {
 286          $db = PearDatabase::getInstance();
 287  
 288          if(!$this->profile_action_permissions) {
 289              $profile2ActionPermissions = array();
 290              if($this->getId()) {
 291                  $sql = 'SELECT * FROM vtiger_profile2standardpermissions WHERE profileid=?';
 292                  $params = array($this->getId());
 293                  $result = $db->pquery($sql, $params);
 294                  $noOfRows = $db->num_rows($result);
 295                  for($i=0; $i<$noOfRows; ++$i) {
 296                      $tabId = $db->query_result($result, $i, 'tabid');
 297                      $operation = $db->query_result($result, $i, 'operation');
 298                      $permissionId = $db->query_result($result, $i, 'permissions');
 299                      $profile2ActionPermissions[$tabId][$operation] = $permissionId;
 300                  }
 301              }
 302              $this->profile_action_permissions = $profile2ActionPermissions;
 303              }
 304          return $this->profile_action_permissions;
 305      }
 306  
 307  	public function getProfileUtilityPermissions() {
 308          $db = PearDatabase::getInstance();
 309  
 310          if(!$this->profile_utility_permissions) {
 311              $profile2UtilityPermissions = array();
 312              if($this->getId()) {
 313                  $sql = 'SELECT * FROM vtiger_profile2utility WHERE profileid=?';
 314                  $params = array($this->getId());
 315                  $result = $db->pquery($sql, $params);
 316                  $noOfRows = $db->num_rows($result);
 317                  for($i=0; $i<$noOfRows; ++$i) {
 318                      $tabId = $db->query_result($result, $i, 'tabid');
 319                      $utility = $db->query_result($result, $i, 'activityid');
 320                      $permissionId = $db->query_result($result, $i, 'permission');
 321                      $profile2UtilityPermissions[$tabId][$utility] = $permissionId;
 322                  }
 323              }
 324              $this->profile_utility_permissions = $profile2UtilityPermissions;
 325          }
 326          return $this->profile_utility_permissions;
 327      }
 328  
 329  	public function getModulePermissions() {
 330          if(!$this->module_permissions) {
 331              $allModules = Vtiger_Module_Model::getAll(array(0), Settings_Profiles_Module_Model::getNonVisibleModulesList());
 332              $eventModule = Vtiger_Module_Model::getInstance('Events');
 333              $allModules[$eventModule->getId()] = $eventModule;
 334              $profileTabPermissions = $this->getProfileTabPermissions();
 335              $profileActionPermissions = $this->getProfileActionPermissions();
 336              $profileUtilityPermissions = $this->getProfileUtilityPermissions();
 337              $allTabActions = Vtiger_Action_Model::getAll(true);
 338  
 339              foreach($allModules as $id => $moduleModel) {
 340                  $permissions = array();
 341                  $permissions['is_permitted'] = Settings_Profiles_Module_Model::IS_PERMITTED_VALUE;
 342                  if(isset($profileTabPermissions[$id])) {
 343                      $permissions['is_permitted'] = $profileTabPermissions[$id];
 344                  }
 345                  $permissions['actions'] = array();
 346                  foreach($allTabActions as $actionModel) {
 347                      $actionId = $actionModel->getId();
 348                      if(isset($profileActionPermissions[$id][$actionId])) {
 349                          $permissions['actions'][$actionId] = $profileActionPermissions[$id][$actionId];
 350                      } elseif(isset($profileUtilityPermissions[$id][$actionId])) {
 351                          $permissions['actions'][$actionId] = $profileUtilityPermissions[$id][$actionId];
 352                      } else {
 353                          $permissions['actions'][$actionId] = Settings_Profiles_Module_Model::NOT_PERMITTED_VALUE;
 354                      }
 355                  }
 356                  $moduleFields = $moduleModel->getFields();
 357                  $allFieldPermissions = $this->getProfileTabFieldPermissions($id);
 358                  foreach($moduleFields as $fieldName => $fieldModel) {
 359                      $fieldPermissions = array();
 360                      $fieldId = $fieldModel->getId();
 361                      $fieldPermissions['visible'] = Settings_Profiles_Module_Model::IS_PERMITTED_VALUE;
 362                      if(isset($allFieldPermissions[$fieldId]['visible'])) {
 363                          $fieldPermissions['visible'] = $allFieldPermissions[$fieldId]['visible'];
 364                      }
 365                      $fieldPermissions['readonly'] = Settings_Profiles_Module_Model::IS_PERMITTED_VALUE;
 366                      if(isset($allFieldPermissions[$fieldId]['readonly'])) {
 367                          $fieldPermissions['readonly'] = $allFieldPermissions[$fieldId]['readonly'];
 368                      }
 369                      $fieldModel->set('permissions', $fieldPermissions);
 370                  }
 371                  $moduleModel->set('permissions', $permissions);
 372              }
 373              $this->module_permissions = $allModules;
 374          }
 375          return $this->module_permissions;
 376      }
 377  
 378  	public function delete($transferToRecord) {
 379          $db = PearDatabase::getInstance();
 380          $profileId = $this->getId();
 381          $transferProfileId = $transferToRecord->getId();
 382  
 383          $db->pquery('DELETE FROM vtiger_profile2globalpermissions WHERE profileid=?', array($profileId));
 384          $db->pquery('DELETE FROM vtiger_profile2tab WHERE profileid=?', array($profileId));
 385          $db->pquery('DELETE FROM vtiger_profile2standardpermissions WHERE profileid=?', array($profileId));
 386          $db->pquery('DELETE FROM vtiger_profile2utility WHERE profileid=?', array($profileId));
 387          $db->pquery('DELETE FROM vtiger_profile2field WHERE profileid=?', array($profileId));
 388  
 389          $checkSql = 'SELECT roleid, count(profileid) AS profilecount FROM vtiger_role2profile
 390                              WHERE roleid IN (select roleid FROM vtiger_role2profile WHERE profileid=?) GROUP BY roleid';
 391          $checkParams = array($profileId);
 392          $checkResult = $db->pquery($checkSql, $checkParams);
 393          $noOfRoles = $db->num_rows($checkResult);
 394          for($i=0; $i<$noOfRoles; ++$i) {
 395              $roleId = $db->query_result($checkResult, $i, 'roleid');
 396              $profileCount = $db->query_result($checkResult, $i, 'profilecount');
 397              if($profileCount > 1) {
 398                  $sql = 'DELETE FROM vtiger_role2profile WHERE roleid=? AND profileid=?';
 399                  $params = array($roleId, $profileId);
 400              } else {
 401                  $sql = 'UPDATE vtiger_role2profile SET profileid=? WHERE roleid=? AND profileid=?';
 402                  $params = array($transferProfileId, $roleId, $profileId);
 403              }
 404              $db->pquery($sql, $params);
 405          }
 406  
 407          $db->pquery('DELETE FROM vtiger_profile WHERE profileid=?', array($profileId));
 408      }
 409  
 410  	public function save() {
 411          $db = PearDatabase::getInstance();
 412          $modulePermissions = $this->getModulePermissions();
 413  
 414          $profileName = $this->get('profilename');
 415          $description = $this->get('description');
 416          $profilePermissions = $this->get('profile_permissions');
 417          $calendarModule = Vtiger_Module_Model::getInstance('Calendar');
 418          $eventModule = Vtiger_Module_Model::getInstance('Events');
 419          $eventFieldsPermissions = $profilePermissions[$eventModule->getId()]['fields'];
 420          $profilePermissions[$eventModule->getId()] = $profilePermissions[$calendarModule->getId()];
 421          $profilePermissions[$eventModule->getId()]['fields'] = $eventFieldsPermissions;
 422  
 423          $isProfileDirectlyRelatedToRole = 0;
 424          $isNewProfile = false;
 425          if($this->has('directly_related_to_role')){
 426              $isProfileDirectlyRelatedToRole = $this->get('directly_related_to_role');
 427          }
 428          $profileId = $this->getId();
 429          if(!$profileId) {
 430              $profileId = $db->getUniqueId('vtiger_profile');
 431              $this->setId($profileId);
 432              $sql = 'INSERT INTO vtiger_profile(profileid, profilename, description, directly_related_to_role) VALUES (?,?,?,?)';
 433              $params = array($profileId, $profileName, $description, $isProfileDirectlyRelatedToRole);
 434              $isNewProfile = true;
 435          } else {
 436              $sql = 'UPDATE vtiger_profile SET profilename=?, description=?, directly_related_to_role=? WHERE profileid=?';
 437              $params = array($profileName, $description, $isProfileDirectlyRelatedToRole, $profileId);
 438  
 439              $db->pquery('DELETE FROM vtiger_profile2globalpermissions WHERE profileid=?', array($profileId));
 440          }
 441          $db->pquery($sql, $params);
 442  
 443          $sql = 'INSERT INTO vtiger_profile2globalpermissions(profileid, globalactionid, globalactionpermission) VALUES (?,?,?)';
 444          $params = array($profileId, Settings_Profiles_Module_Model::GLOBAL_ACTION_VIEW, $this->tranformInputPermissionValue($this->get('viewall')));
 445          $db->pquery($sql, $params);
 446  
 447          $sql = 'INSERT INTO vtiger_profile2globalpermissions(profileid, globalactionid, globalactionpermission) VALUES (?,?,?)';
 448          $params = array($profileId, Settings_Profiles_Module_Model::GLOBAL_ACTION_EDIT, $this->tranformInputPermissionValue($this->get('editall')));
 449          $db->pquery($sql, $params);
 450  
 451          $allModuleModules = Vtiger_Module_Model::getAll(array(0), Settings_Profiles_Module_Model::getNonVisibleModulesList());
 452          $allModuleModules[$eventModule->getId()] = $eventModule;
 453          if(count($allModuleModules) > 0) {
 454              $actionModels = Vtiger_Action_Model::getAll(true);
 455              foreach($allModuleModules as $tabId => $moduleModel) {
 456                  if($moduleModel->isActive()) {
 457                      $this->saveModulePermissions($moduleModel, $profilePermissions[$moduleModel->getId()]);
 458                  } else {
 459                      $permissions = array();
 460                      $permissions['is_permitted'] = Settings_Profiles_Module_Model::IS_PERMITTED_VALUE;
 461                      if($moduleModel->isEntityModule()) {
 462                          $permissions['actions'] = array();
 463                          foreach($actionModels as $actionModel) {
 464                              if($actionModel->isModuleEnabled($moduleModel)) {
 465                                  $permissions['actions'][$actionModel->getId()] = Settings_Profiles_Module_Model::IS_PERMITTED_VALUE;
 466                              }
 467                          }
 468                          $permissions['fields'] = array();
 469                          $moduleFields = $moduleModel->getFields();
 470                          foreach($moduleFields as $fieldModel) {
 471                              if($fieldModel->isEditEnabled()) {
 472                                  $permissions['fields'][$fieldModel->getId()] = Settings_Profiles_Record_Model::PROFILE_FIELD_READWRITE;
 473                              } elseif ($fieldModel->isViewEnabled()) {
 474                                  $permissions['fields'][$fieldModel->getId()] = Settings_Profiles_Record_Model::PROFILE_FIELD_READONLY;
 475                              } else {
 476                                  $permissions['fields'][$fieldModel->getId()] = Settings_Profiles_Record_Model::PROFILE_FIELD_INACTIVE;
 477                              }
 478                          }
 479                      }
 480                      $this->saveModulePermissions($moduleModel, $permissions);
 481                  }
 482              }
 483          }
 484          if($isNewProfile){
 485              $this->saveUserAccessbleFieldsIntoProfile2Field();
 486          }
 487          
 488          $this->recalculate();
 489          return $profileId;
 490      }
 491  
 492  	protected function saveModulePermissions($moduleModel, $permissions) {
 493          $db = PearDatabase::getInstance();
 494          $profileId = $this->getId();
 495          $tabId = $moduleModel->getId();
 496          $profileActionPermissions = $this->getProfileActionPermissions();
 497          $profileActionPermissions = $profileActionPermissions[$tabId];
 498  
 499          $db->pquery('DELETE FROM vtiger_profile2tab WHERE profileid=? AND tabid=?', array($profileId, $tabId));
 500  
 501          $actionPermissions = array();
 502          $actionPermissions = $permissions['actions'];
 503          $actionEnabled = false;
 504          if($moduleModel->isEntityModule() || $moduleModel->isUtilityActionEnabled()) {
 505              if($actionPermissions || $moduleModel->isUtilityActionEnabled()) {
 506                  $actionIdsList = Vtiger_Action_Model::$standardActions;
 507                  unset($actionIdsList[3]);
 508                  $availableActionIds = array_keys($actionIdsList);
 509  
 510                  foreach ($availableActionIds as $actionId) {
 511                      if ($actionId === 0) {
 512                          //Save action permissions = Permissions of Create/Editview action
 513                          $actionPermissions[$actionId] = $actionPermissions[1];
 514                      } else {
 515                          $actionPermissions[$actionId] = $actionPermissions[$actionId];
 516                      }
 517                  }
 518  
 519                  //Dividing on actions
 520                  $actionsIdsList = $utilityIdsList = array();
 521                  foreach($actionPermissions as $actionId => $permission) {
 522                      if(isset(Vtiger_Action_Model::$standardActions[$actionId])) {
 523                          $actionsIdsList[$actionId] = $permission;
 524                      } else {
 525                          $utilityIdsList[$actionId] = $permission;
 526                      }
 527                  }
 528  
 529                  //Update process
 530                  if ($profileActionPermissions) {
 531                      //Standard permissions
 532                      $actionsUpdateQuery = 'UPDATE vtiger_profile2standardpermissions SET permissions = CASE ';
 533                      foreach ($actionsIdsList as $actionId => $permission) {
 534                          $permissionValue = $this->tranformInputPermissionValue($permission);
 535                          if(isset(Vtiger_Action_Model::$standardActions[$actionId])) {
 536                              if($permission == Settings_Profiles_Module_Model::IS_PERMITTED_VALUE) {
 537                                  $actionEnabled = true;
 538                              }
 539                              $actionsUpdateQuery .= " WHEN operation = $actionId THEN $permissionValue ";
 540                          }
 541                      }
 542                      $actionsUpdateQuery .= 'ELSE permissions END WHERE profileid = ? AND tabid = ?';
 543                      if ($actionsIdsList) {
 544                          $db->pquery($actionsUpdateQuery, array($profileId, $tabId));
 545                      }
 546                      
 547                      foreach (Vtiger_Action_Model::$utilityActions as $utilityActionId => $utilityActionName) {
 548                          if(!isset($utilityIdsList[$utilityActionId])) {
 549                              $utilityIdsList[$utilityActionId] = 'off';
 550                          }
 551                      }
 552                      //Utility permissions
 553                      $utilityUpdateQuery = 'UPDATE vtiger_profile2utility SET permission = CASE ';
 554                      foreach($utilityIdsList as $actionId => $permission) {
 555                          $permissionValue = $this->tranformInputPermissionValue($permission);
 556                          $utilityUpdateQuery .= " WHEN activityid = $actionId THEN $permissionValue ";
 557                      }
 558                      if ($utilityIdsList) {
 559                          $utilityUpdateQuery .= 'ELSE ? END WHERE profileid = ? AND tabid = ?';
 560                          $db->pquery($utilityUpdateQuery, array(1, $profileId, $tabId));
 561                      }
 562                  } else {
 563                      //Insert Process
 564                      //Standard permissions
 565                      $i = 0;
 566                      $count = count($actionsIdsList);
 567                      $actionsInsertQuery .= 'INSERT INTO vtiger_profile2standardpermissions(profileid, tabid, operation, permissions) VALUES ';
 568                      foreach ($actionsIdsList as $actionId => $permission) {
 569                          $actionEnabled = true;
 570                          $permissionValue = $this->tranformInputPermissionValue($permission);
 571                          $actionsInsertQuery .= "($profileId, $tabId, $actionId, $permissionValue)";
 572  
 573                          if ($i !== $count-1) {
 574                              $actionsInsertQuery .= ', ';
 575                          }
 576                          $i++;
 577                      }
 578                      if ($actionsIdsList) {
 579                          $db->pquery($actionsInsertQuery, array());
 580                      }
 581  
 582                      //Utility permissions
 583                      $i = 0;
 584                      $count = count($utilityIdsList);
 585                      $utilityInsertQuery .= 'INSERT INTO vtiger_profile2utility(profileid, tabid, activityid, permission) VALUES ';
 586                      foreach($utilityIdsList as $actionId => $permission) {
 587                          $permissionValue = $this->tranformInputPermissionValue($permission);
 588                          $utilityInsertQuery .= "($profileId, $tabId, $actionId, $permissionValue)";
 589  
 590                          if ($i !== $count-1) {
 591                              $utilityInsertQuery .= ', ';
 592                          }
 593                          $i++;
 594                      }
 595                      if ($utilityIdsList) {
 596                          $db->pquery($utilityInsertQuery, array());
 597                      }
 598                  }
 599              } elseif ($this->isRestrictedModule($moduleModel->getName())) {
 600                  //To check the module is restricted or not(Emails, Webmails)
 601                  $actionEnabled = true;
 602              }
 603          } else {
 604              $actionEnabled = true;
 605          }
 606  
 607          // Enable module permission in profile2tab table only if either its an extension module or the entity module has atleast 1 action enabled
 608          if($actionEnabled) {
 609              $isModulePermitted = $this->tranformInputPermissionValue($permissions['is_permitted']);
 610          } else {
 611              $isModulePermitted = Settings_Profiles_Module_Model::NOT_PERMITTED_VALUE;
 612          }
 613          $sql = 'INSERT INTO vtiger_profile2tab(profileid, tabid, permissions) VALUES (?,?,?)';
 614          $params = array($profileId, $tabId, $isModulePermitted);
 615          $db->pquery($sql, $params);
 616  
 617          $fieldPermissions = $permissions['fields'];
 618          if(is_array($fieldPermissions)) {
 619              foreach($fieldPermissions as $fieldId => $stateValue) {
 620                  $db->pquery('DELETE FROM vtiger_profile2field WHERE profileid=? AND tabid=? AND fieldid=?',
 621                                  array($profileId, $tabId, $fieldId));
 622                  if($stateValue == Settings_Profiles_Record_Model::PROFILE_FIELD_INACTIVE) {
 623                      $visible = Settings_Profiles_Module_Model::FIELD_INACTIVE;
 624                      $readOnly = Settings_Profiles_Module_Model::IS_PERMITTED_VALUE;
 625                  } elseif($stateValue == Settings_Profiles_Record_Model::PROFILE_FIELD_READONLY) {
 626                      $visible = Settings_Profiles_Module_Model::FIELD_ACTIVE;
 627                      $readOnly = Settings_Profiles_Module_Model::FIELD_READONLY;
 628                  } else {
 629                      $visible = Settings_Profiles_Module_Model::FIELD_ACTIVE;
 630                      $readOnly = Settings_Profiles_Module_Model::FIELD_READWRITE;
 631                  }
 632                  $sql = 'INSERT INTO vtiger_profile2field(profileid, tabid, fieldid, visible, readonly) VALUES (?,?,?,?,?)';
 633                  $params = array($profileId, $tabId, $fieldId, $visible, $readOnly);
 634                  $db->pquery($sql, $params);
 635              }
 636          }
 637      }
 638  
 639  	protected function tranformInputPermissionValue($value) {
 640          if($value == 'on' || $value == '1') {
 641              return Settings_Profiles_Module_Model::IS_PERMITTED_VALUE;
 642          } else {
 643              return Settings_Profiles_Module_Model::NOT_PERMITTED_VALUE;
 644          }
 645      }
 646  
 647      /**
 648       * Function to get the list view actions for the record
 649       * @return <Array> - Associate array of Vtiger_Link_Model instances
 650       */
 651  	public function getRecordLinks() {
 652  
 653          $links = array();
 654  
 655          $recordLinks = array(
 656              array(
 657                  'linktype' => 'LISTVIEWRECORD',
 658                  'linklabel' => 'LBL_EDIT_RECORD',
 659                  'linkurl' => $this->getEditViewUrl(),
 660                  'linkicon' => 'icon-pencil'
 661              ),
 662              array(
 663                  'linktype' => 'LISTVIEWRECORD',
 664                  'linklabel' => 'LBL_DUPLICATE_RECORD',
 665                  'linkurl' => $this->getDuplicateViewUrl(),
 666                  'linkicon' => 'icon-share'
 667              ),
 668              array(
 669                  'linktype' => 'LISTVIEWRECORD',
 670                  'linklabel' => 'LBL_DELETE_RECORD',
 671                  'linkurl' => "javascript:Settings_Vtiger_List_Js.triggerDelete(event,'".$this->getDeleteActionUrl()."')",
 672                  'linkicon' => 'icon-trash'
 673              )
 674          );
 675          foreach($recordLinks as $recordLink) {
 676              $links[] = Vtiger_Link_Model::getInstanceFromValues($recordLink);
 677          }
 678  
 679          return $links;
 680      }
 681  
 682  	public static function getInstanceFromQResult($result, $rowNo=0) {
 683          $db = PearDatabase::getInstance();
 684          $row = $db->query_result_rowdata($result, $rowNo);
 685          $profile = new self();
 686          return $profile->setData($row);
 687      }
 688  
 689      /**
 690       * Function to get all the profiles linked to the given role
 691       * @param <String> - $roleId
 692       * @return <Array> - Array of Settings_Profiles_Record_Model instances
 693       */
 694  	public static function getAllByRole($roleId) {
 695          $db = PearDatabase::getInstance();
 696  
 697          $sql = 'SELECT vtiger_profile.*
 698                      FROM vtiger_profile
 699                      INNER JOIN
 700                          vtiger_role2profile ON vtiger_profile.profileid = vtiger_role2profile.profileid
 701                          AND
 702                          vtiger_role2profile.roleid = ?';
 703          $params = array($roleId);
 704          $result = $db->pquery($sql, $params);
 705          $noOfProfiles = $db->num_rows($result);
 706          $profiles = array();
 707          for ($i=0; $i<$noOfProfiles; ++$i) {
 708              $profile = self::getInstanceFromQResult($result, $i);
 709              $profiles[$profile->getId()] = $profile;
 710          }
 711          return $profiles;
 712      }
 713  
 714      /**
 715       * Function to get all the profiles
 716       * @return <Array> - Array of Settings_Profiles_Record_Model instances
 717       */
 718  	public static function getAll() {
 719          $db = PearDatabase::getInstance();
 720  
 721          $sql = 'SELECT * FROM vtiger_profile';
 722          $params = array();
 723          $result = $db->pquery($sql, $params);
 724          $noOfProfiles = $db->num_rows($result);
 725          $profiles = array();
 726          for ($i=0; $i<$noOfProfiles; ++$i) {
 727              $profile = self::getInstanceFromQResult($result, $i);
 728              $profiles[$profile->getId()] = $profile;
 729          }
 730          return $profiles;
 731      }
 732  
 733      /**
 734       * Function to get the instance of Profile model, given profile id
 735       * @param <Integer> $profileId
 736       * @return Settings_Profiles_Record_Model instance, if exists. Null otherwise
 737       */
 738  	public static function getInstanceById($profileId) {
 739          $db = PearDatabase::getInstance();
 740  
 741          $sql = 'SELECT * FROM vtiger_profile WHERE profileid = ?';
 742          $params = array($profileId);
 743          $result = $db->pquery($sql, $params);
 744          if($db->num_rows($result) > 0) {
 745              return self::getInstanceFromQResult($result);
 746          }
 747          return null;
 748      }
 749  
 750      public static function getInstanceByName($profileName , $checkOnlyDirectlyRelated=false, $excludedRecordId = array()) {
 751          $db = PearDatabase::getInstance();
 752          $query = 'SELECT * FROM vtiger_profile WHERE profilename=?';
 753          $params = array($profileName);
 754          if($checkOnlyDirectlyRelated) {
 755              $query .=' AND directly_related_to_role=1';
 756          }
 757          if(!empty($excludedRecordId)) {
 758             $query .= ' AND profileid NOT IN ('.generateQuestionMarks($excludedRecordId).')';
 759             $params = array_merge($params,$excludedRecordId);
 760         }
 761         
 762          $result = $db->pquery($query, $params);
 763          if($db->num_rows($result)> 0 ){
 764              return self::getInstanceFromQResult($result);
 765          }
 766          return null;
 767      }
 768  
 769      /**
 770       * Function to get the Detail Url for the current group
 771       * @return <String>
 772       */
 773      public function getDetailViewUrl() {
 774          return '?module=Profiles&parent=Settings&view=Detail&record=' . $this->getId();
 775      }
 776  
 777      /**
 778       * Function to check whether the profiles is directly related to role
 779       * @return Boolean
 780       */
 781      public function isDirectlyRelated() {
 782          $isDirectlyRelated = $this->get('directly_related_to_role');
 783          if($isDirectlyRelated == 1){
 784              return true;
 785          } else {
 786              return false;
 787          }
 788      }
 789  
 790      /**
 791       * Function to check whether module is restricted for to show actions and field access
 792       * @param <String> $moduleName
 793       * @return <boolean> true/false
 794       */
 795  	public function isRestrictedModule($moduleName) {
 796          return in_array($moduleName, array('Emails'));
 797      }
 798  
 799      /**
 800       * Function recalculate the sharing rules
 801       */
 802  	public function recalculate() {
 803          set_time_limit(vglobal('php_max_execution_time'));
 804          require_once ('modules/Users/CreateUserPrivilegeFile.php');
 805  
 806          $userIdsList = $this->getUsersList();
 807          if ($userIdsList) {
 808              foreach ($userIdsList as $userId) {
 809                  createUserPrivilegesfile($userId);
 810              }
 811          }
 812      }
 813  
 814      /**
 815       * Function to get Users list from this Profile
 816       * @param <Boolean> $allUsers
 817       * @return <Array> list of user ids
 818       */
 819  	public function getUsersList($allUsers = false) {
 820          $db = PearDatabase::getInstance();
 821          $params = array(0);
 822          $query = 'SELECT id FROM vtiger_users
 823                      INNER JOIN vtiger_user2role ON vtiger_user2role.userid = vtiger_users.id
 824                      INNER JOIN vtiger_role2profile ON vtiger_role2profile.roleid = vtiger_user2role.roleid
 825                      WHERE vtiger_users.deleted = ?';
 826  
 827          if (!$allUsers) {
 828              $query .= ' AND vtiger_role2profile.profileid = ?';
 829              $params[] = $this->getId();
 830          }
 831          $result = $db->pquery($query, $params);
 832          $numOfRows = $db->num_rows($result);
 833  
 834          $userIdsList = array();
 835          for($i=0; $i<$numOfRows; $i++) {
 836              $userIdsList[] = $db->query_result($result, $i, 'id');
 837          }
 838          return $userIdsList;
 839      }
 840      
 841      /**
 842       * Function to save user fields in vtiger_profile2field table
 843       * We need user field values to generating the Email Templates variable valuues.
 844       * @param type $profileId
 845       */
 846  	public function saveUserAccessbleFieldsIntoProfile2Field(){
 847          $profileId = $this->getId();
 848          if(!empty($profileId)){
 849              $db = PearDatabase::getInstance();
 850              $userRecordModel = Users_Record_Model::getCurrentUserModel();
 851              $module = $userRecordModel->getModuleName();
 852              $tabId = getTabid($module);
 853              $userModuleModel = Users_Module_Model::getInstance($module);
 854              $moduleFields = $userModuleModel->getFields();
 855  
 856              $userAccessbleFields = array();
 857              $skipFields = array(98,115,116,31,32);
 858              foreach ($moduleFields as $fieldName => $fieldModel) {
 859                  if($fieldModel->getFieldDataType() == 'string' || $fieldModel->getFieldDataType() == 'email' || $fieldModel->getFieldDataType() == 'phone') {
 860                      if(!in_array($fieldModel->get('uitype'), $skipFields) && $fieldName != 'asterisk_extension'){
 861                          $userAccessbleFields[$fieldModel->get('id')] .= $fieldName;
 862                      }
 863                  }
 864              }
 865  
 866              //Added user fields into vtiger_profile2field and vtiger_def_org_field
 867              //We are using this field information in Email Templates.
 868              foreach ($userAccessbleFields as $fieldId => $fieldName) {
 869                  $insertQuery = 'INSERT INTO vtiger_profile2field VALUES(?,?,?,?,?)';
 870                  $db->pquery($insertQuery, array($profileId, $tabId, $fieldId,  Settings_Profiles_Module_Model::FIELD_ACTIVE, Settings_Profiles_Module_Model::FIELD_READWRITE));
 871              }
 872              
 873              $sql = 'SELECT fieldid FROM vtiger_def_org_field WHERE tabid = ?';
 874              $result1 = $db->pquery($sql, array($tabId));
 875              $def_org_fields = array();
 876              for($j=0; $j<$db->num_rows($result1); $j++) {
 877                  array_push($def_org_fields, $db->query_result($result1, $j, 'fieldid'));
 878              }
 879              foreach ($userAccessbleFields as $fieldId => $fieldName) {
 880                  if(!in_array($fieldId, $def_org_fields)){
 881                      $insertQuery = 'INSERT INTO vtiger_def_org_field VALUES(?,?,?,?)';
 882                      $db->pquery($insertQuery, array($tabId,$fieldId,0,0));
 883                  }
 884              }
 885          }
 886      }
 887  }