CRM/Core/CodeGen/Specification.php

   1 <?php
   2
   3 /**
   4  * Read the schema specification and parse into internal data structures
   5  */
   6 class CRM_Core_CodeGen_Specification {
   7   public $tables;
   8   public $database;
   9
  10   protected $classNames;
  11
  12   /**
  13    * Read and parse.
  14    *
  15    * @param string $buildVersion which version of the schema to build
  16    */
  17   function parse($schemaPath, $buildVersion) {
  18     $this->buildVersion = $buildVersion;
  19
  20     echo "Parsing schema description ".$schemaPath."\n";
  21     $dbXML = CRM_Core_CodeGen_Util_Xml::parse($schemaPath);
  22     // print_r( $dbXML );
  23
  24     echo "Extracting database information\n";
  25     $this->database = &$this->getDatabase($dbXML);
  26     // print_r( $this->database );
  27
  28     $this->classNames = array();
  29
  30     # TODO: peel DAO-specific stuff out of getTables, and spec reading into its own class
  31     echo "Extracting table information\n";
  32     $this->tables = $this->getTables($dbXML, $this->database);
  33
  34     $this->resolveForeignKeys($this->tables, $this->classNames);
  35     $this->tables = $this->orderTables($this->tables);
  36
  37     // add archive tables here
  38     $archiveTables = array( );
  39     foreach ($this->tables as $name => $table ) {
  40       if ( $table['archive'] == 'true' ) {
  41         $name = 'archive_' . $table['name'];
  42         $table['name'] = $name;
  43         $table['archive'] = 'false';
  44         if ( isset($table['foreignKey']) ) {
  45           foreach ($table['foreignKey'] as $fkName => $fkValue) {
  46             if ($this->tables[$fkValue['table']]['archive'] == 'true') {
  47               $table['foreignKey'][$fkName]['table'] = 'archive_' . $table['foreignKey'][$fkName]['table'];
  48               $table['foreignKey'][$fkName]['uniqName'] =
  49                 str_replace( 'FK_', 'FK_archive_', $table['foreignKey'][$fkName]['uniqName'] );
  50             }
  51           }
  52           $archiveTables[$name] = $table;
  53         }
  54       }
  55     }
  56   }
  57
  58   function &getDatabase(&$dbXML) {
  59     $database = array('name' => trim((string ) $dbXML->name));
  60
  61     $attributes = '';
  62     $this->checkAndAppend($attributes, $dbXML, 'character_set', 'DEFAULT CHARACTER SET ', '');
  63     $this->checkAndAppend($attributes, $dbXML, 'collate', 'COLLATE ', '');
  64     $database['attributes'] = $attributes;
  65
  66     $tableAttributes_modern = $tableAttributes_simple = '';
  67     $this->checkAndAppend($tableAttributes_modern, $dbXML, 'table_type', 'ENGINE=', '');
  68     $this->checkAndAppend($tableAttributes_simple, $dbXML, 'table_type', 'TYPE=', '');
  69     $database['tableAttributes_modern'] = trim($tableAttributes_modern . ' ' . $attributes);
  70     $database['tableAttributes_simple'] = trim($tableAttributes_simple);
  71
  72     $database['comment'] = $this->value('comment', $dbXML, '');
  73
  74     return $database;
  75   }
  76
  77   function getTables($dbXML, &$database) {
  78     $tables = array();
  79     foreach ($dbXML->tables as $tablesXML) {
  80       foreach ($tablesXML->table as $tableXML) {
  81         if ($this->value('drop', $tableXML, 0) > 0 and $this->value('drop', $tableXML, 0) <= $this->buildVersion) {
  82           continue;
  83         }
  84
  85         if ($this->value('add', $tableXML, 0) <= $this->buildVersion) {
  86           $this->getTable($tableXML, $database, $tables);
  87         }
  88       }
  89     }
  90
  91     return $tables;
  92   }
  93
  94   function resolveForeignKeys(&$tables, &$classNames) {
  95     foreach (array_keys($tables) as $name) {
  96       $this->resolveForeignKey($tables, $classNames, $name);
  97     }
  98   }
  99
 100   function resolveForeignKey(&$tables, &$classNames, $name) {
 101     if (!array_key_exists('foreignKey', $tables[$name])) {
 102       return;
 103     }
 104
 105     foreach (array_keys($tables[$name]['foreignKey']) as $fkey) {
 106       $ftable = $tables[$name]['foreignKey'][$fkey]['table'];
 107       if (!array_key_exists($ftable, $classNames)) {
 108         echo "$ftable is not a valid foreign key table in $name\n";
 109         continue;
 110       }
 111       $tables[$name]['foreignKey'][$fkey]['className'] = $classNames[$ftable];
 112       $tables[$name]['foreignKey'][$fkey]['fileName'] = str_replace('_', '/', $classNames[$ftable]) . '.php';
 113       $tables[$name]['fields'][$fkey]['FKClassName'] = $classNames[$ftable];
 114     }
 115   }
 116
 117   function orderTables(&$tables) {
 118     $ordered = array();
 119
 120     while (!empty($tables)) {
 121       foreach (array_keys($tables) as $name) {
 122         if ($this->validTable($tables, $ordered, $name)) {
 123           $ordered[$name] = $tables[$name];
 124           unset($tables[$name]);
 125         }
 126       }
 127     }
 128     return $ordered;
 129   }
 130
 131   function validTable(&$tables, &$valid, $name) {
 132     if (!array_key_exists('foreignKey', $tables[$name])) {
 133       return TRUE;
 134     }
 135
 136     foreach (array_keys($tables[$name]['foreignKey']) as $fkey) {
 137       $ftable = $tables[$name]['foreignKey'][$fkey]['table'];
 138       if (!array_key_exists($ftable, $valid) && $ftable !== $name) {
 139         return FALSE;
 140       }
 141     }
 142     return TRUE;
 143   }
 144
 145   function getTable($tableXML, &$database, &$tables) {
 146     $name = trim((string ) $tableXML->name);
 147     $klass = trim((string ) $tableXML->class);
 148     $base = $this->value('base', $tableXML);
 149     $sourceFile = "xml/schema/{$base}/{$klass}.xml";
 150     $daoPath = "{$base}/DAO/";
 151     $pre = str_replace('/', '_', $daoPath);
 152     $this->classNames[$name] = $pre . $klass;
 153
 154     $localizable = FALSE;
 155     foreach ($tableXML->field as $fieldXML) {
 156       if ($fieldXML->localizable) {
 157         $localizable = TRUE;
 158         break;
 159       }
 160     }
 161
 162     $table = array(
 163       'name' => $name,
 164       'base' => $daoPath,
 165       'sourceFile' => $sourceFile,
 166       'fileName' => $klass . '.php',
 167       'objectName' => $klass,
 168       'labelName' => substr($name, 8),
 169       'className' => $this->classNames[$name],
 170       'attributes_simple' => trim($database['tableAttributes_simple']),
 171       'attributes_modern' => trim($database['tableAttributes_modern']),
 172       'comment' => $this->value('comment', $tableXML),
 173       'localizable' => $localizable,
 174       'log' => $this->value('log', $tableXML, 'false'),
 175       'archive' => $this->value('archive', $tableXML, 'false'),
 176     );
 177
 178     $fields = array();
 179     foreach ($tableXML->field as $fieldXML) {
 180       if ($this->value('drop', $fieldXML, 0) > 0 and $this->value('drop', $fieldXML, 0) <= $this->buildVersion) {
 181         continue;
 182       }
 183
 184       if ($this->value('add', $fieldXML, 0) <= $this->buildVersion) {
 185         $this->getField($fieldXML, $fields);
 186       }
 187     }
 188
 189     $table['fields'] = &$fields;
 190     $table['hasEnum'] = FALSE;
 191     foreach ($table['fields'] as $field) {
 192       if ($field['crmType'] == 'CRM_Utils_Type::T_ENUM') {
 193         $table['hasEnum'] = TRUE;
 194         break;
 195       }
 196     }
 197
 198     if ($this->value('primaryKey', $tableXML)) {
 199       $this->getPrimaryKey($tableXML->primaryKey, $fields, $table);
 200     }
 201
 202     // some kind of refresh?
 203     CRM_Core_Config::singleton(FALSE);
 204     if ($this->value('index', $tableXML)) {
 205       $index = array();
 206       foreach ($tableXML->index as $indexXML) {
 207         if ($this->value('drop', $indexXML, 0) > 0 and $this->value('drop', $indexXML, 0) <= $this->buildVersion) {
 208           continue;
 209         }
 210
 211         $this->getIndex($indexXML, $fields, $index);
 212       }
 213       $table['index'] = &$index;
 214     }
 215
 216     if ($this->value('foreignKey', $tableXML)) {
 217       $foreign = array();
 218       foreach ($tableXML->foreignKey as $foreignXML) {
 219         // print_r($foreignXML);
 220
 221         if ($this->value('drop', $foreignXML, 0) > 0 and $this->value('drop', $foreignXML, 0) <= $this->buildVersion) {
 222           continue;
 223         }
 224         if ($this->value('add', $foreignXML, 0) <= $this->buildVersion) {
 225           $this->getForeignKey($foreignXML, $fields, $foreign, $name);
 226         }
 227       }
 228       $table['foreignKey'] = &$foreign;
 229     }
 230
 231     if ($this->value('dynamicForeignKey', $tableXML)) {
 232       $dynamicForeign = array();
 233       foreach ($tableXML->dynamicForeignKey as $foreignXML) {
 234         if ($this->value('drop', $foreignXML, 0) > 0 and $this->value('drop', $foreignXML, 0) <= $this->buildVersion) {
 235           continue;
 236         }
 237         if ($this->value('add', $foreignXML, 0) <= $this->buildVersion) {
 238           $this->getDynamicForeignKey($foreignXML, $dynamicForeign, $name);
 239         }
 240       }
 241       $table['dynamicForeignKey'] = $dynamicForeign;
 242     }
 243
 244     $tables[$name] = &$table;
 245     return;
 246   }
 247
 248   function getField(&$fieldXML, &$fields) {
 249     $name  = trim((string ) $fieldXML->name);
 250     $field = array('name' => $name, 'localizable' => $fieldXML->localizable);
 251     $type  = (string ) $fieldXML->type;
 252     switch ($type) {
 253       case 'varchar':
 254       case 'char':
 255         $field['length'] = (int) $fieldXML->length;
 256         $field['sqlType'] = "$type({$field['length']})";
 257         $field['phpType'] = 'string';
 258         $field['crmType'] = 'CRM_Utils_Type::T_STRING';
 259         $field['size'] = $this->getSize($fieldXML);
 260         break;
 261
 262       case 'enum':
 263         $value               = (string ) $fieldXML->values;
 264         $field['sqlType']    = 'enum(';
 265         $field['values']     = array();
 266         $field['enumValues'] = $value;
 267         $values              = explode(',', $value);
 268         $first               = TRUE;
 269         foreach ($values as $v) {
 270           $v = trim($v);
 271           $field['values'][] = $v;
 272
 273           if (!$first) {
 274             $field['sqlType'] .= ', ';
 275           }
 276           $first = FALSE;
 277           $field['sqlType'] .= "'$v'";
 278         }
 279         $field['sqlType'] .= ')';
 280         $field['phpType'] = $field['sqlType'];
 281         $field['crmType'] = 'CRM_Utils_Type::T_ENUM';
 282         break;
 283
 284       case 'text':
 285         $field['sqlType'] = $field['phpType'] = $type;
 286         $field['crmType'] = 'CRM_Utils_Type::T_' . strtoupper($type);
 287         // CRM-13497 see fixme below
 288         $field['rows'] = isset($fieldXML->html) ? $this->value('rows', $fieldXML->html) : NULL;
 289         $field['cols'] = isset($fieldXML->html) ? $this->value('cols', $fieldXML->html) : NULL;
 290         break;
 291         break;
 292
 293       case 'datetime':
 294         $field['sqlType'] = $field['phpType'] = $type;
 295         $field['crmType'] = 'CRM_Utils_Type::T_DATE + CRM_Utils_Type::T_TIME';
 296         break;
 297
 298       case 'boolean':
 299         // need this case since some versions of mysql do not have boolean as a valid column type and hence it
 300         // is changed to tinyint. hopefully after 2 yrs this case can be removed.
 301         $field['sqlType'] = 'tinyint';
 302         $field['phpType'] = $type;
 303         $field['crmType'] = 'CRM_Utils_Type::T_' . strtoupper($type);
 304         break;
 305
 306       case 'decimal':
 307         $length = $fieldXML->length ? $fieldXML->length : '20,2';
 308         $field['sqlType'] = 'decimal(' . $length . ')';
 309         $field['phpType'] = 'float';
 310         $field['crmType'] = 'CRM_Utils_Type::T_MONEY';
 311         break;
 312
 313       case 'float':
 314         $field['sqlType'] = 'double';
 315         $field['phpType'] = 'float';
 316         $field['crmType'] = 'CRM_Utils_Type::T_FLOAT';
 317         break;
 318
 319       default:
 320         $field['sqlType'] = $field['phpType'] = $type;
 321         if ($type == 'int unsigned') {
 322           $field['crmType'] = 'CRM_Utils_Type::T_INT';
 323         }
 324         else {
 325           $field['crmType'] = 'CRM_Utils_Type::T_' . strtoupper($type);
 326         }
 327         break;
 328     }
 329
 330     $field['required'] = $this->value('required', $fieldXML);
 331     $field['collate']  = $this->value('collate', $fieldXML);
 332     $field['comment']  = $this->value('comment', $fieldXML);
 333     $field['default']  = $this->value('default', $fieldXML);
 334     $field['import']   = $this->value('import', $fieldXML);
 335     if ($this->value('export', $fieldXML)) {
 336       $field['export'] = $this->value('export', $fieldXML);
 337     }
 338     else {
 339       $field['export'] = $this->value('import', $fieldXML);
 340     }
 341     $field['rule'] = $this->value('rule', $fieldXML);
 342     $field['title'] = $this->value('title', $fieldXML);
 343     if (!$field['title']) {
 344       $field['title'] = $this->composeTitle($name);
 345     }
 346     $field['headerPattern'] = $this->value('headerPattern', $fieldXML);
 347     $field['dataPattern'] = $this->value('dataPattern', $fieldXML);
 348     $field['uniqueName'] = $this->value('uniqueName', $fieldXML);
 349     $field['html'] = $this->value('html', $fieldXML);
 350     if (!empty($field['html'])) {
 351       $validOptions = array(
 352         'type',
 353         /* Fixme: prior to CRM-13497 these were in a flat structure
 354         // CRM-13497 moved them to be nested within 'html' but there's no point
 355         // making that change in the DAOs right now since we are in the process of
 356         // moving to docrtine anyway.
 357         // So translating from nested xml back to flat structure for now.
 358         'rows',
 359         'cols',
 360         'size', */
 361       );
 362       $field['html'] = array();
 363       foreach ($validOptions as $htmlOption) {
 364         if(!empty($fieldXML->html->$htmlOption)){
 365           $field['html'][$htmlOption] = $this->value($htmlOption, $fieldXML->html);
 366         }
 367       }
 368     }
 369     $field['pseudoconstant'] = $this->value('pseudoconstant', $fieldXML);
 370     if(!empty($field['pseudoconstant'])){
 371       //ok this is a bit long-winded but it gets there & is consistent with above approach
 372       $field['pseudoconstant'] = array();
 373       $validOptions = array(
 374         // Fields can specify EITHER optionGroupName OR table, not both
 375         // (since declaring optionGroupName means we are using the civicrm_option_value table)
 376         'optionGroupName',
 377         'table',
 378         // If table is specified, keyColumn and labelColumn are also required
 379         'keyColumn',
 380         'labelColumn',
 381         // Non-translated machine name for programmatic lookup. Defaults to 'name' if that column exists
 382         'nameColumn',
 383         // Where clause snippet (will be joined to the rest of the query with AND operator)
 384         'condition',
 385       );
 386       foreach ($validOptions as $pseudoOption) {
 387         if(!empty($fieldXML->pseudoconstant->$pseudoOption)){
 388           $field['pseudoconstant'][$pseudoOption] = $this->value($pseudoOption, $fieldXML->pseudoconstant);
 389         }
 390       }
 391       // For now, fields that have option lists that are not in the db can simply
 392       // declare an empty pseudoconstant tag and we'll add this placeholder.
 393       // That field's BAO::buildOptions fn will need to be responsible for generating the option list
 394       if (empty($field['pseudoconstant'])) {
 395         $field['pseudoconstant'] = 'not in database';
 396       }
 397     }
 398     $fields[$name] = &$field;
 399   }
 400
 401   function composeTitle($name) {
 402     $names = explode('_', strtolower($name));
 403     $title = '';
 404     for ($i = 0; $i < count($names); $i++) {
 405       if ($names[$i] === 'id' || $names[$i] === 'is') {
 406         // id's do not get titles
 407         return NULL;
 408       }
 409
 410       if ($names[$i] === 'im') {
 411         $names[$i] = 'IM';
 412       }
 413       else {
 414         $names[$i] = ucfirst(trim($names[$i]));
 415       }
 416
 417       $title = $title . ' ' . $names[$i];
 418     }
 419     return trim($title);
 420   }
 421
 422   function getPrimaryKey(&$primaryXML, &$fields, &$table) {
 423     $name = trim((string ) $primaryXML->name);
 424
 425     /** need to make sure there is a field of type name */
 426     if (!array_key_exists($name, $fields)) {
 427         echo "primary key $name in $table->name does not have a field definition, ignoring\n";
 428       return;
 429     }
 430
 431     // set the autoincrement property of the field
 432     $auto = $this->value('autoincrement', $primaryXML);
 433     $fields[$name]['autoincrement'] = $auto;
 434     $primaryKey = array(
 435       'name' => $name,
 436       'autoincrement' => $auto,
 437     );
 438     $table['primaryKey'] = &$primaryKey;
 439   }
 440
 441   function getIndex(&$indexXML, &$fields, &$indices) {
 442     //echo "\n\n*******************************************************\n";
 443     //echo "entering getIndex\n";
 444
 445     $index = array();
 446     // empty index name is fine
 447     $indexName      = trim((string)$indexXML->name);
 448     $index['name']  = $indexName;
 449     $index['field'] = array();
 450
 451     // populate fields
 452     foreach ($indexXML->fieldName as $v) {
 453       $fieldName = (string)($v);
 454       $length = (string)($v['length']);
 455       if (strlen($length) > 0) {
 456         $fieldName = "$fieldName($length)";
 457       }
 458       $index['field'][] = $fieldName;
 459     }
 460
 461     $index['localizable'] = FALSE;
 462     foreach ($index['field'] as $fieldName) {
 463       if (isset($fields[$fieldName]) and $fields[$fieldName]['localizable']) {
 464         $index['localizable'] = TRUE;
 465         break;
 466       }
 467     }
 468
 469     // check for unique index
 470     if ($this->value('unique', $indexXML)) {
 471       $index['unique'] = TRUE;
 472     }
 473
 474     //echo "\$index = \n";
 475     //print_r($index);
 476
 477     // field array cannot be empty
 478     if (empty($index['field'])) {
 479       echo "No fields defined for index $indexName\n";
 480       return;
 481     }
 482
 483     // all fieldnames have to be defined and should exist in schema.
 484     foreach ($index['field'] as $fieldName) {
 485       if (!$fieldName) {
 486         echo "Invalid field defination for index $indexName\n";
 487         return;
 488       }
 489       $parenOffset = strpos($fieldName, '(');
 490       if ($parenOffset > 0) {
 491         $fieldName = substr($fieldName, 0, $parenOffset);
 492       }
 493       if (!array_key_exists($fieldName, $fields)) {
 494         echo "Table does not contain $fieldName\n";
 495         print_r($fields);
 496         exit();
 497       }
 498     }
 499     $indices[$indexName] = &$index;
 500   }
 501
 502   function getForeignKey(&$foreignXML, &$fields, &$foreignKeys, &$currentTableName) {
 503     $name = trim((string ) $foreignXML->name);
 504
 505     /** need to make sure there is a field of type name */
 506     if (!array_key_exists($name, $fields)) {
 507         echo "foreign $name in $currentTableName does not have a field definition, ignoring\n";
 508       return;
 509     }
 510
 511     /** need to check for existence of table and key **/
 512     $table = trim($this->value('table', $foreignXML));
 513     $foreignKey = array(
 514       'name' => $name,
 515       'table' => $table,
 516       'uniqName' => "FK_{$currentTableName}_{$name}",
 517       'key' => trim($this->value('key', $foreignXML)),
 518       'import' => $this->value('import', $foreignXML, FALSE),
 519       'export' => $this->value('import', $foreignXML, FALSE),
 520       // we do this matching in a seperate phase (resolveForeignKeys)
 521       'className' => NULL,
 522       'onDelete' => $this->value('onDelete', $foreignXML, FALSE),
 523     );
 524     $foreignKeys[$name] = &$foreignKey;
 525   }
 526
 527   function getDynamicForeignKey(&$foreignXML, &$dynamicForeignKeys) {
 528     $foreignKey = array(
 529       'idColumn' => trim($foreignXML->idColumn),
 530       'typeColumn' => trim($foreignXML->typeColumn),
 531       'key' => trim($this->value('key', $foreignXML)),
 532     );
 533     $dynamicForeignKeys[] = $foreignKey;
 534   }
 535
 536   protected function value($key, &$object, $default = NULL) {
 537     if (isset($object->$key)) {
 538       return (string ) $object->$key;
 539     }
 540     return $default;
 541   }
 542
 543   protected function checkAndAppend(&$attributes, &$object, $name, $pre = NULL, $post = NULL) {
 544     if (!isset($object->$name)) {
 545       return;
 546     }
 547
 548     $value = $pre . trim($object->$name) . $post;
 549     $this->append($attributes, ' ', trim($value));
 550   }
 551
 552   protected function append(&$str, $delim, $name) {
 553     if (empty($name)) {
 554       return;
 555     }
 556
 557     if (is_array($name)) {
 558       foreach ($name as $n) {
 559         if (empty($n)) {
 560           continue;
 561         }
 562         if (empty($str)) {
 563           $str = $n;
 564         }
 565         else {
 566           $str .= $delim . $n;
 567         }
 568       }
 569     }
 570     else {
 571       if (empty($str)) {
 572         $str = $name;
 573       }
 574       else {
 575         $str .= $delim . $name;
 576       }
 577     }
 578   }
 579
 580   /**
 581    * Sets the size property of a textfield
 582    * See constants defined in CRM_Utils_Type for possible values
 583    */
 584   protected function getSize($fieldXML) {
 585     // Extract from <size> tag if supplied
 586     if (!empty($fieldXML->html) && $this->value('size', $fieldXML->html)) {
 587       $const = 'CRM_Utils_Type::' . strtoupper($fieldXML->html->size);
 588       if (defined($const)) {
 589         return $const;
 590       }
 591     }
 592     // Infer from <length> tag if <size> was not explicitly set or was invalid
 593
 594     // This map is slightly different from CRM_Core_Form_Renderer::$_sizeMapper
 595     // Because we usually want fields to render as smaller than their maxlength
 596     $sizes = array(
 597       2 => 'TWO',
 598       4 => 'FOUR',
 599       6 => 'SIX',
 600       8 => 'EIGHT',
 601       16 => 'TWELVE',
 602       32 => 'MEDIUM',
 603       64 => 'BIG',
 604     );
 605     foreach ($sizes as $length => $name) {
 606       if ($fieldXML->length <= $length) {
 607         return "CRM_Utils_Type::$name";
 608       }
 609     }
 610     return 'CRM_Utils_Type::HUGE';
 611   }
 612 }