[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  class VtigerCRMActorMeta extends EntityMeta {
  12      protected $pearDB;
  13      protected static $fieldTypeMapping = array();
  14      protected static $referenceTypeMapping = array();
  15      
  16  	function VtigerCRMActorMeta($tableName,$webserviceObject,$adb,$user){
  17          parent::__construct($webserviceObject,$user);
  18          $this->baseTable = $tableName;
  19          $this->idColumn = null;
  20          
  21          $this->pearDB = $adb;
  22          $this->tableList = array($this->baseTable);
  23          $this->tableIndexList = null;
  24          $this->defaultTableList = array();
  25      }
  26      
  27      public function getIdColumn() {
  28          if($this->idColumn === null) {
  29              $this->getModuleFields();
  30          }
  31          return parent::getIdColumn();
  32      }
  33      
  34      public function getObectIndexColumn() {
  35          return $this->getIdColumn();
  36      }
  37      
  38  	public function getEntityTableIndexList() {
  39          if($this->tableIndexList === null){
  40              $this->tableIndexList = array($this->baseTable=>$this->getIdColumn());
  41          }
  42          
  43          return parent::getEntityTableIndexList();
  44      }
  45      
  46  	public function getModuleFields() {
  47          if ($this->moduleFields === null) {
  48              $fieldList = $this->getTableFieldList($this->baseTable);
  49              $this->moduleFields = array();
  50              foreach ($fieldList as $field) {
  51                  $this->moduleFields[$field->getFieldName()] = $field;
  52              }
  53          }
  54          return $this->moduleFields;
  55      }
  56      
  57  	protected function getTableFieldList($tableName){
  58          $tableFieldList = array();
  59          
  60          $factory = WebserviceField::fromArray($this->pearDB,array('tablename'=>$tableName));
  61          $dbTableFields = $factory->getTableFields();
  62          foreach ($dbTableFields as $dbField) {
  63              if($dbField->primary_key){
  64                  if($this->idColumn === null){
  65                      $this->idColumn = $dbField->name;
  66                  }else{
  67                      throw new WebServiceException(WebServiceErrorCode::$UNKOWNENTITY,
  68                          "Entity table with multi column primary key is not supported");
  69                  }
  70              }
  71              $field = $this->getFieldArrayFromDBField($dbField,$tableName);
  72              $webserviceField = WebserviceField::fromArray($this->pearDB,$field);
  73              $fieldDataType = $this->getFieldType($dbField,$tableName);
  74              if($fieldDataType === null){
  75                  $fieldDataType = $this->getFieldDataTypeFromDBType($dbField->type);
  76              }
  77              $webserviceField->setFieldDataType($fieldDataType);
  78              if(strcasecmp($fieldDataType,'reference') === 0){
  79                  $webserviceField->setReferenceList($this->getReferenceList($dbField,$tableName));
  80              }
  81              array_push($tableFieldList,$webserviceField);
  82          }
  83          return $tableFieldList;
  84      }
  85      
  86  	protected function getFieldArrayFromDBField($dbField,$tableName){
  87          $field = array();
  88          $field['fieldname'] = $dbField->name;
  89          $field['columnname'] = $dbField->name;
  90          $field['tablename'] = $tableName;
  91          $field['fieldlabel'] = str_replace('_', ' ',$dbField->name);
  92          $field['displaytype'] = 1;
  93          $field['uitype'] = 1;
  94          $fieldDataType = $this->getFieldType($dbField,$tableName);
  95          if($fieldDataType !== null){
  96              $fieldType = $this->getTypeOfDataForType($fieldDataType);
  97          }else{
  98              $fieldType = $this->getTypeOfDataForType($dbField->type);
  99          }
 100          $typeOfData = null;
 101          if(($dbField->not_null && !$dbField->primary_key) || $dbField->unique_key == 1){
 102              $typeOfData = $fieldType.'~M';
 103          }else{
 104              $typeOfData = $fieldType.'~O';
 105          }
 106          $field['typeofdata'] = $typeOfData;
 107          $field['tabid'] = null;
 108          $field['fieldid'] = null;
 109          $field['masseditable'] = 0;
 110          $field['presence'] = '0';
 111          return $field;
 112      }
 113      
 114  	protected function getReferenceList($dbField, $tableName){
 115          static $referenceList = array();
 116          if(isset($referenceList[$dbField->name])){
 117              return $referenceList[$dbField->name];
 118          }
 119          if(!isset(VtigerCRMActorMeta::$fieldTypeMapping[$tableName][$dbField->name])){
 120              $this->getFieldType($dbField, $tableName);
 121          }
 122          $fieldTypeData = VtigerCRMActorMeta::$fieldTypeMapping[$tableName][$dbField->name];
 123          
 124          if (empty(VtigerCRMActorMeta::$referenceTypeMapping)) {
 125              $sql = "SELECT * FROM vtiger_ws_entity_referencetype";
 126              $result = $this->pearDB->pquery($sql, array());
 127              for ($index =0, $count = $this->pearDB->num_rows($result); $index < $count; ++$index) {
 128                  $row = $this->pearDB->query_result_rowdata($result, $index);
 129                  VtigerCRMActorMeta::$referenceTypeMapping[$row['fieldtypeid']][] = $row['type'];
 130              }
 131          }
 132          
 133          $referenceTypes = array();
 134          if (isset(VtigerCRMActorMeta::$referenceTypeMapping[$fieldTypeData['fieldtypeid']])) {
 135              $referenceTypes = VtigerCRMActorMeta::$referenceTypeMapping[$fieldTypeData['fieldtypeid']];
 136          }
 137          // update private cache
 138          $referenceList[$dbField->name] = $referenceTypes;
 139          
 140          return $referenceTypes;
 141      }
 142      
 143  	protected function getFieldType($dbField,$tableName){
 144          
 145          if(isset(VtigerCRMActorMeta::$fieldTypeMapping[$tableName][$dbField->name])){
 146              if(VtigerCRMActorMeta::$fieldTypeMapping[$tableName][$dbField->name] === 'null'){
 147                  return null;
 148              }
 149              $row = VtigerCRMActorMeta::$fieldTypeMapping[$tableName][$dbField->name];
 150              return $row['fieldtype'];
 151          }
 152          
 153          if (empty(VtigerCRMActorMeta::$fieldTypeMapping)) {
 154              // Optimization to avoid repeated initialization
 155              $sql = "select * from vtiger_ws_entity_fieldtype";
 156              $result = $this->pearDB->pquery($sql,array());
 157              $rowCount = $this->pearDB->num_rows($result);
 158              while ($rowCount) {
 159                  $row = $this->pearDB->query_result_rowdata($result,$rowCount-1);
 160                  VtigerCRMActorMeta::$fieldTypeMapping[$row['table_name']][$row['field_name']] = $row;
 161                  --$rowCount;
 162              }
 163          }
 164          
 165          if (!isset(VtigerCRMActorMeta::$fieldTypeMapping[$tableName][$dbField->name])) {
 166              VtigerCRMActorMeta::$fieldTypeMapping[$tableName][$dbField->name] = 'null';
 167              return null;
 168          }
 169          return VtigerCRMActorMeta::$fieldTypeMapping[$tableName][$dbField->name]['fieldtype'];
 170      }
 171      
 172  	protected function getTypeOfDataForType($type){
 173          switch($type){
 174              case 'email': return 'E';
 175              case 'password': return 'P';
 176              case 'date': return 'D';
 177              case 'datetime': return 'DT';
 178              case 'timestamp': return 'T';
 179              case 'int':
 180              case 'integer': return 'I';
 181              case 'decimal':
 182              case 'numeric': return 'N';
 183              case 'varchar':
 184              case 'text':
 185              default: return 'V';
 186          }
 187      }
 188      
 189  	protected function getFieldDataTypeFromDBType($type){
 190          switch($type){
 191              case 'date': return 'date';
 192              case 'datetime': return 'datetime';
 193              case 'timestamp': return 'time';
 194              case 'int':
 195              case 'integer': return 'integer';
 196              case 'real':
 197              case 'decimal':
 198              case 'numeric': return 'double';
 199              case 'text': return 'text';
 200              case 'varchar': return 'string';
 201              default: return $type;
 202          }
 203      }
 204      
 205  	public function hasPermission($operation,$webserviceId){
 206          if(is_admin($this->user)){
 207              return true;
 208          }else{
 209              if(strcmp($operation,EntityMeta::$RETRIEVE)===0){
 210                  return true;
 211              }
 212              return false;
 213          }
 214      }
 215      
 216  	public function hasAssignPrivilege($ownerWebserviceId){
 217          if(is_admin($this->user)){
 218              return true;
 219          }else{
 220              $idComponents = vtws_getIdComponents($webserviceId);
 221              $userId=$idComponents[1];
 222              if($this->user->id === $userId){
 223                  return true;
 224              }
 225              return false;
 226          }
 227      }
 228      
 229  	public function hasDeleteAccess(){
 230          if(is_admin($this->user)){
 231              return true;
 232          }else{
 233              return false;
 234          }
 235      }
 236      
 237  	public function hasAccess(){
 238          return true;
 239      }
 240      
 241  	public function hasReadAccess(){
 242          return true;
 243      }
 244      
 245  	public function hasWriteAccess(){
 246          if(is_admin($this->user)){
 247              return true;
 248          }else{
 249              return false;
 250          }
 251      }
 252      
 253  	public function getEntityName(){
 254          return $this->webserviceObject->getEntityName();
 255      }
 256  	public function getEntityId(){
 257          return $this->webserviceObject->getEntityId();
 258      }
 259      
 260  	function getObjectEntityName($webserviceId){
 261          
 262          $idComponents = vtws_getIdComponents($webserviceId);
 263          $id=$idComponents[1];
 264  
 265          if($this->exists($id)){
 266              return $this->webserviceObject->getEntityName();
 267          }
 268          return null;
 269      }
 270      
 271  	function exists($recordId){
 272          $exists = false;
 273          $sql = 'select 1 from '.$this->baseTable.' where '.$this->getObectIndexColumn().'=?';
 274          $result = $this->pearDB->pquery($sql , array($recordId));
 275          if($result != null && isset($result)){
 276              if($this->pearDB->num_rows($result)>0){
 277                  $exists = true;
 278              }
 279          }
 280          return $exists;
 281      }
 282      
 283  	public function getNameFields(){
 284          $query = "select name_fields from vtiger_ws_entity_name where entity_id = ?";
 285          $result = $this->pearDB->pquery($query, array($this->objectId));
 286          $fieldNames = '';
 287          if($result){
 288              $rowCount = $this->pearDB->num_rows($result);
 289              if($rowCount > 0){
 290                  $fieldNames = $this->pearDB->query_result($result,0,'name_fields');
 291              }
 292          }
 293          return $fieldNames;
 294      }
 295      
 296  	public function getName($webserviceId){
 297          
 298          $idComponents = vtws_getIdComponents($webserviceId);
 299          $entityId = $idComponents[0];
 300          $id=$idComponents[1];
 301          
 302          $nameList = vtws_getActorEntityNameById($entityId, array($id));
 303          return $nameList[$id];
 304      }
 305  
 306  	public function getEntityAccessControlQuery() {
 307          return '';
 308      }
 309  
 310  	public function getEntityDeletedQuery() {
 311          if($this->getEntityName() == 'Currency'){
 312              return 'vtiger_currency_info.deleted=0';
 313          }
 314  
 315          return '';
 316      }
 317  
 318  	public function isModuleEntity() {
 319          return false;
 320      }
 321  }
 322  ?>