1: <?php
2:
3: 4: 5: 6: 7: 8: 9: 10: 11: 12: 13: 14: 15: 16: 17: 18: 19: 20: 21: 22: 23: 24: 25: 26: 27: 28: 29: 30: 31: 32: 33: 34: 35: 36: 37: 38: 39: 40: 41: 42: 43: 44: 45: 46:
47: abstract class AlphaDAO {
48: 49: 50: 51: 52: 53:
54: protected $OID;
55:
56: 57: 58: 59: 60: 61:
62: protected $lastQuery;
63:
64: 65: 66: 67: 68: 69:
70: protected $version_num;
71:
72: 73: 74: 75: 76: 77:
78: protected $created_ts;
79:
80: 81: 82: 83: 84: 85:
86: protected $created_by;
87:
88: 89: 90: 91: 92: 93:
94: protected $updated_ts;
95:
96: 97: 98: 99: 100: 101:
102: protected $updated_by;
103:
104: 105: 106: 107: 108: 109:
110: protected $defaultAttributes = array("OID", "lastQuery", "version_num", "dataLabels", "created_ts", "created_by", "updated_ts", "updated_by", "defaultAttributes", "transientAttributes", "uniqueAttributes", "TABLE_NAME", "logger");
111:
112: 113: 114: 115: 116: 117:
118: protected $transientAttributes = array("lastQuery", "dataLabels", "defaultAttributes", "transientAttributes", "uniqueAttributes", "TABLE_NAME", "logger");
119:
120: 121: 122: 123: 124: 125:
126: protected $uniqueAttributes = array();
127:
128: 129: 130: 131: 132: 133:
134: protected $dataLabels = array();
135:
136: 137: 138: 139: 140: 141:
142: private static $logger = null;
143:
144: 145: 146: 147: 148: 149:
150: private $maintainHistory = false;
151:
152: 153: 154: 155: 156:
157: public function __construct() {
158: self::$logger = new Logger('AlphaDAO');
159: self::$logger->debug('>>__construct()');
160:
161: $this->version_num = new Integer(0);
162: $this->created_ts = new Timestamp(date("Y-m-d H:i:s"));
163: $person_ID = (isset($_SESSION['currentUser'])? $_SESSION['currentUser']->getOID(): 0);
164: $this->created_by = new Integer($person_ID);
165: $this->updated_ts = new Timestamp(date("Y-m-d H:i:s"));
166: $this->updated_by = new Integer($person_ID);
167:
168: self::$logger->debug('<<__construct');
169: }
170:
171: 172: 173: 174: 175: 176: 177: 178:
179: public static function getConnection() {
180: throw new AlphaException('The static getConnection() method is not longer supported! Please update your code to instantiate a AlphaDAOProviderInterface '.
181: 'instance, then invoke the query() method on that instance to run a custom query.');
182: }
183:
184: 185: 186: 187: 188:
189: public static function disconnect() {
190: global $config;
191:
192: $provider = AlphaDAOProviderFactory::getInstance($config->get('db.provider.name'), new PersonObject());
193: $provider->disconnect();
194: }
195:
196: 197: 198: 199: 200: 201: 202: 203:
204: public function query($sqlQuery) {
205: self::$logger->debug('>>query(sqlQuery=['.$sqlQuery.'])');
206:
207: global $config;
208:
209: $provider = AlphaDAOProviderFactory::getInstance($config->get('db.provider.name'), $this);
210: $result = $provider->query($sqlQuery);
211:
212: self::$logger->debug('<<query ['.print_r($result, true).']');
213: return $result;
214: }
215:
216: 217: 218: 219: 220: 221: 222:
223: public function load($OID) {
224: self::$logger->debug('>>load(OID=['.$OID.'])');
225:
226: if(method_exists($this, 'before_load_callback'))
227: $this->before_load_callback();
228:
229: global $config;
230:
231: $this->OID = $OID;
232:
233: if($config->get('cache.provider.name') != '' && $this->loadFromCache()) {
234:
235: }else{
236: $provider = AlphaDAOProviderFactory::getInstance($config->get('db.provider.name'), $this);
237: $provider->load($OID);
238:
239: if($config->get('cache.provider.name') != '')
240: $this->addToCache();
241: }
242:
243: $this->setEnumOptions();
244:
245: if(method_exists($this, 'after_load_callback'))
246: $this->after_load_callback();
247:
248: self::$logger->debug('<<load');
249: }
250:
251: 252: 253: 254: 255: 256: 257: 258: 259: 260:
261: public function loadByAttribute($attribute, $value, $ignoreClassType=false, $loadAttributes=array()) {
262: self::$logger->debug('>>loadByAttribute(attribute=['.$attribute.'], value=['.$value.'], ignoreClassType=['.$ignoreClassType.'],
263: loadAttributes=['.var_export($loadAttributes, true).'])');
264:
265: if(method_exists($this, 'before_loadByAttribute_callback'))
266: $this->before_loadByAttribute_callback();
267:
268: global $config;
269:
270: $provider = AlphaDAOProviderFactory::getInstance($config->get('db.provider.name'), $this);
271: $provider->loadByAttribute($attribute, $value, $ignoreClassType, $loadAttributes);
272:
273: $this->setEnumOptions();
274:
275: if($config->get('cache.provider.name') != '' && count($loadAttributes) == 0)
276: $this->addToCache();
277:
278: if(method_exists($this, 'after_loadByAttribute_callback'))
279: $this->after_loadByAttribute_callback();
280:
281: self::$logger->debug('<<loadByAttribute');
282: }
283:
284: 285: 286: 287: 288: 289: 290: 291: 292: 293: 294: 295:
296: public function loadAll($start=0, $limit=0, $orderBy='OID', $order='ASC', $ignoreClassType=false) {
297: self::$logger->debug('>>loadAll(start=['.$start.'], limit=['.$limit.'], orderBy=['.$orderBy.'], order=['.$order.'], ignoreClassType=['.$ignoreClassType.']');
298:
299: if(method_exists($this, 'before_loadAll_callback'))
300: $this->before_loadAll_callback();
301:
302: global $config;
303:
304: $provider = AlphaDAOProviderFactory::getInstance($config->get('db.provider.name'), $this);
305: $objects = $provider->loadAll($start, $limit, $orderBy, $order, $ignoreClassType);
306:
307: if(method_exists($this, 'after_loadAll_callback'))
308: $this->after_loadAll_callback();
309:
310: self::$logger->debug('<<loadAll ['.count($objects).']');
311: return $objects;
312: }
313:
314: 315: 316: 317: 318: 319: 320: 321: 322: 323: 324: 325: 326: 327: 328: 329:
330: public function loadAllByAttribute($attribute, $value, $start=0, $limit=0, $orderBy="OID", $order="ASC", $ignoreClassType=false, $constructorArgs=array()) {
331: self::$logger->debug('>>loadAllByAttribute(attribute=['.$attribute.'], value=['.$value.'], start=['.$start.'], limit=['.$limit.'], orderBy=['.$orderBy.'], order=['.$order.'], ignoreClassType=['.$ignoreClassType.'], constructorArgs=['.print_r($constructorArgs, true).']');
332:
333: if(method_exists($this, 'before_loadAllByAttribute_callback'))
334: $this->before_loadAllByAttribute_callback();
335:
336: global $config;
337:
338: $provider = AlphaDAOProviderFactory::getInstance($config->get('db.provider.name'), $this);
339: $objects = $provider->loadAllByAttribute($attribute, $value, $start, $limit, $orderBy, $order, $ignoreClassType);
340:
341: if(method_exists($this, 'after_loadAllByAttribute_callback'))
342: $this->after_loadAllByAttribute_callback();
343:
344: self::$logger->debug('<<loadAllByAttribute ['.count($objects).']');
345: return $objects;
346: }
347:
348: 349: 350: 351: 352: 353: 354: 355: 356: 357: 358: 359: 360: 361: 362:
363: public function loadAllByAttributes($attributes=array(), $values=array(), $start=0, $limit=0, $orderBy='OID', $order='ASC', $ignoreClassType=false) {
364: self::$logger->debug('>>loadAllByAttributes(attributes=['.var_export($attributes, true).'], values=['.var_export($values, true).'], start=['.
365: $start.'], limit=['.$limit.'], orderBy=['.$orderBy.'], order=['.$order.'], ignoreClassType=['.$ignoreClassType.']');
366:
367: if(method_exists($this, 'before_loadAllByAttributes_callback'))
368: $this->before_loadAllByAttributes_callback();
369:
370: global $config;
371:
372: if(!is_array($attributes) || !is_array($values)) {
373: throw new IllegalArguementException('Illegal arrays attributes=['.var_export($attributes, true).'] and values=['.var_export($values, true).
374: '] provided to loadAllByAttributes');
375: }
376:
377: $provider = AlphaDAOProviderFactory::getInstance($config->get('db.provider.name'), $this);
378: $objects = $provider->loadAllByAttributes($attributes, $values, $start, $limit, $orderBy, $order, $ignoreClassType);
379:
380: if(method_exists($this, 'after_loadAllByAttributes_callback'))
381: $this->after_loadAllByAttributes_callback();
382:
383: self::$logger->debug('<<loadAllByAttributes ['.count($objects).']');
384: return $objects;
385: }
386:
387: 388: 389: 390: 391: 392: 393: 394: 395: 396: 397: 398: 399:
400: public function loadAllByDayUpdated($date, $start=0, $limit=0, $orderBy="OID", $order="ASC", $ignoreClassType=false) {
401: self::$logger->debug('>>loadAllByDayUpdated(date=['.$date.'], start=['.$start.'], limit=['.$limit.'], orderBy=['.$orderBy.'], order=['.$order.'], ignoreClassType=['.$ignoreClassType.']');
402:
403: if(method_exists($this, 'before_loadAllByDayUpdated_callback'))
404: $this->before_loadAllByDayUpdated_callback();
405:
406: global $config;
407:
408: $provider = AlphaDAOProviderFactory::getInstance($config->get('db.provider.name'), $this);
409: $objects = $provider->loadAllByDayUpdated($date, $start, $limit, $orderBy, $order, $ignoreClassType);
410:
411: if(method_exists($this, 'after_loadAllByDayUpdated_callback'))
412: $this->after_loadAllByDayUpdated_callback();
413:
414: self::$logger->debug('<<loadAllByDayUpdated ['.count($objects).']');
415: return $objects;
416: }
417:
418: 419: 420: 421: 422: 423: 424: 425: 426: 427: 428: 429: 430:
431: public function loadAllFieldValuesByAttribute($attribute, $value, $returnAttribute, $order='ASC', $ignoreClassType=false) {
432: self::$logger->debug('>>loadAllFieldValuesByAttribute(attribute=['.$attribute.'], value=['.$value.'], returnAttribute=['.$returnAttribute.'], order=['.$order.'], ignoreClassType=['.$ignoreClassType.']');
433:
434: global $config;
435:
436: $provider = AlphaDAOProviderFactory::getInstance($config->get('db.provider.name'), $this);
437: $values = $provider->loadAllFieldValuesByAttribute($attribute, $value, $returnAttribute, $order, $ignoreClassType);
438:
439: self::$logger->debug('<<loadAllFieldValuesByAttribute ['.count($values).']');
440: return $values;
441: }
442:
443: 444: 445: 446: 447: 448: 449: 450:
451: public function save() {
452: self::$logger->debug('>>save()');
453:
454: if(method_exists($this, 'before_save_callback'))
455: $this->before_save_callback();
456:
457: global $config;
458:
459:
460: if(!$this->validate()) {
461: throw new FailedSaveException('Could not save due to a validation error.');
462: return;
463: }else{
464: $provider = AlphaDAOProviderFactory::getInstance($config->get('db.provider.name'), $this);
465: $provider->save();
466:
467: if($config->get('cache.provider.name') != '') {
468: $this->removeFromCache();
469: $this->addToCache();
470: }
471:
472: if(method_exists($this, 'after_save_callback'))
473: $this->after_save_callback();
474: }
475: }
476:
477: 478: 479: 480: 481: 482: 483: 484: 485: 486:
487: public function saveAttribute($attribute, $value) {
488: self::$logger->debug('>>saveAttribute(attribute=['.$attribute.'], value=['.$value.'])');
489:
490: if(method_exists($this, 'before_saveAttribute_callback'))
491: $this->before_saveAttribute_callback();
492:
493: global $config;
494:
495: if(!isset($this->$attribute))
496: throw new IllegalArguementException('Could not perform save, as the attribute ['.$attribute.'] is not present on the class['.get_class($this).']');
497:
498: if($this->isTransient())
499: throw new FailedSaveException('Cannot perform saveAttribute method on transient BO!');
500:
501: $provider = AlphaDAOProviderFactory::getInstance($config->get('db.provider.name'), $this);
502: $provider->saveAttribute($attribute, $value);
503:
504: if($config->get('cache.provider.name') != '') {
505: $this->removeFromCache();
506: $this->addToCache();
507: }
508:
509: if(method_exists($this, 'after_saveAttribute_callback'))
510: $this->after_saveAttribute_callback();
511:
512: self::$logger->debug('<<saveAttribute');
513: }
514:
515: 516: 517: 518: 519: 520:
521: public function saveHistory() {
522: self::$logger->debug('>>saveHistory()');
523:
524: if(method_exists($this, 'before_saveHistory_callback'))
525: $this->before_saveHistory_callback();
526:
527: global $config;
528:
529: $provider = AlphaDAOProviderFactory::getInstance($config->get('db.provider.name'), $this);
530: $provider->saveHistory();
531:
532: if(method_exists($this, 'after_saveHistory_callback'))
533: $this->after_saveHistory_callback();
534: }
535:
536: 537: 538: 539: 540: 541: 542:
543: protected function validate() {
544: self::$logger->debug('>>validate()');
545:
546: if(method_exists($this, 'before_validate_callback'))
547: $this->before_validate_callback();
548:
549: $valid = true;
550:
551:
552: $reflection = new ReflectionClass(get_class($this));
553: $properties = $reflection->getProperties();
554:
555: foreach($properties as $propObj) {
556: $propName = $propObj->name;
557: if(!in_array($propName, $this->defaultAttributes) && !in_array($propName, $this->transientAttributes)) {
558: $propClass = get_class($this->getPropObject($propName));
559: if (mb_strtoupper($propClass) != "ENUM" &&
560: mb_strtoupper($propClass) != "DENUM" &&
561: mb_strtoupper($propClass) != "DENUMITEM" &&
562: mb_strtoupper($propClass) != "BOOLEAN") {
563: if ($this->getPropObject($propName) != false && !preg_match($this->getPropObject($propName)->getRule(), $this->getPropObject($propName)->getValue())) {
564: throw new ValidationException('Failed to save, validation error is: '.$this->getPropObject($propName)->getHelper());
565: $valid = false;
566: }
567: }
568: }
569: }
570:
571: if(method_exists($this, 'after_validate_callback'))
572: $this->after_validate_callback();
573:
574: self::$logger->debug('<<validate ['.$valid.']');
575: return $valid;
576: }
577:
578: 579: 580: 581: 582: 583:
584: public function delete() {
585: self::$logger->debug('>>delete()');
586:
587: if(method_exists($this, 'before_delete_callback'))
588: $this->before_delete_callback();
589:
590: global $config;
591:
592:
593: $reflection = new ReflectionClass(get_class($this));
594: $properties = $reflection->getProperties();
595:
596:
597: foreach($properties as $propObj) {
598: $propName = $propObj->name;
599:
600: if(!$propObj->isPrivate() && isset($this->$propName) && $this->$propName instanceof Relation) {
601: $prop = $this->getPropObject($propName);
602:
603:
604: if($prop->getRelationType() == 'MANY-TO-MANY') {
605: self::$logger->debug('Deleting MANY-TO-MANY lookup objects...');
606:
607: try{
608:
609: $side = $prop->getSide(get_class($this));
610: }catch (IllegalArguementException $iae) {
611: $side = $prop->getSide(ucfirst($this->getTableName()).'Object');
612: }
613:
614: self::$logger->debug('Side is ['.$side.']'.$this->getOID());
615:
616: $lookUp = $prop->getLookup();
617: self::$logger->debug('Lookup object['.var_export($lookUp, true).']');
618:
619:
620: if($side == 'left')
621: $lookUp->deleteAllByAttribute('leftID', $this->getOID());
622: else
623: $lookUp->deleteAllByAttribute('rightID', $this->getOID());
624: self::$logger->debug('...done deleting!');
625: }
626:
627:
628: if($prop->getRelationType() == 'ONE-TO-MANY' && !$prop->getRelatedClass() == 'TagObject') {
629: $relatedObjects = $prop->getRelatedObjects();
630:
631: foreach($relatedObjects as $object) {
632: $object->set($prop->getRelatedClassField(), null);
633: $object->save();
634: }
635: }
636:
637:
638: if($prop->getRelationType() == 'ONE-TO-MANY' && $prop->getRelatedClass() == 'TagObject') {
639:
640: $prop->setValue($this->getOID());
641: $relatedObjects = $prop->getRelatedObjects();
642:
643: foreach($relatedObjects as $object) {
644: $object->delete();
645: }
646: }
647: }
648: }
649:
650: $provider = AlphaDAOProviderFactory::getInstance($config->get('db.provider.name'), $this);
651: $provider->delete();
652:
653: if($config->get('cache.provider.name') != '')
654: $this->removeFromCache();
655:
656: if(method_exists($this, 'after_delete_callback'))
657: $this->after_delete_callback();
658:
659: $this->clear();
660: self::$logger->debug('<<delete');
661: }
662:
663: 664: 665: 666: 667: 668: 669: 670: 671:
672: public function deleteAllByAttribute($attribute, $value) {
673: self::$logger->debug('>>deleteAllByAttribute(attribute=['.$attribute.'], value=['.$value.'])');
674:
675: if(method_exists($this, 'before_deleteAllByAttribute_callback'))
676: $this->before_deleteAllByAttribute_callback();
677:
678: try {
679: $doomedObjects = $this->loadAllByAttribute($attribute, $value);
680: $deletedRowCount = 0;
681:
682: foreach ($doomedObjects as $object) {
683: $object->delete();
684: $deletedRowCount++;
685: }
686: }catch (BONotFoundException $bonf) {
687:
688: self::$logger->warn($bonf->getMessage());
689: return 0;
690: }catch (AlphaException $e) {
691: throw new FailedDeleteException('Failed to delete objects, error is ['.$e->getMessage().']');
692: self::$logger->debug('<<deleteAllByAttribute [0]');
693: return 0;
694: }
695:
696: if(method_exists($this, 'after_deleteAllByAttribute_callback'))
697: $this->after_deleteAllByAttribute_callback();
698:
699: self::$logger->debug('<<deleteAllByAttribute ['.$deletedRowCount.']');
700: return $deletedRowCount;
701: }
702:
703: 704: 705: 706: 707: 708: 709:
710: public function getVersion() {
711: self::$logger->debug('>>getVersion()');
712:
713: if(method_exists($this, 'before_getVersion_callback'))
714: $this->before_getVersion_callback();
715:
716: global $config;
717:
718: $provider = AlphaDAOProviderFactory::getInstance($config->get('db.provider.name'), $this);
719: $ver = $provider->getVersion();
720:
721: if(method_exists($this, 'after_getVersion_callback'))
722: $this->after_getVersion_callback();
723:
724: self::$logger->debug('<<getVersion ['.$ver.']');
725: return $ver;
726: }
727:
728: 729: 730: 731: 732: 733:
734: public function makeTable() {
735: self::$logger->debug('>>makeTable()');
736:
737: if(method_exists($this, 'before_makeTable_callback'))
738: $this->before_makeTable_callback();
739:
740: global $config;
741:
742: $provider = AlphaDAOProviderFactory::getInstance($config->get('db.provider.name'), $this);
743: $provider->makeTable();
744:
745: if(method_exists($this, 'after_makeTable_callback'))
746: $this->after_makeTable_callback();
747:
748: self::$logger->info('Successfully created the table ['.$this->getTableName().'] for the class ['.get_class($this).']');
749:
750: self::$logger->debug('<<makeTable');
751: }
752:
753: 754: 755: 756: 757: 758:
759: public function makeHistoryTable() {
760: self::$logger->debug('>>makeHistoryTable()');
761:
762: if(method_exists($this, 'before_makeHistoryTable_callback'))
763: $this->before_makeHistoryTable_callback();
764:
765: global $config;
766:
767: $provider = AlphaDAOProviderFactory::getInstance($config->get('db.provider.name'), $this);
768: $provider->makeHistoryTable();
769:
770: if(method_exists($this, 'after_makeHistoryTable_callback'))
771: $this->after_makeHistoryTable_callback();
772:
773: self::$logger->info('Successfully created the table ['.$this->getTableName().'_history] for the class ['.get_class($this).']');
774:
775: self::$logger->debug('<<makeHistoryTable');
776: }
777:
778: 779: 780: 781: 782: 783:
784: public function rebuildTable() {
785: self::$logger->debug('>>rebuildTable()');
786:
787: if(method_exists($this, 'before_rebuildTable_callback'))
788: $this->before_rebuildTable_callback();
789:
790: global $config;
791:
792: $provider = AlphaDAOProviderFactory::getInstance($config->get('db.provider.name'), $this);
793: $provider->rebuildTable();
794:
795: if(method_exists($this, 'after_rebuildTable_callback'))
796: $this->after_rebuildTable_callback();
797:
798: self::$logger->debug('<<rebuildTable');
799: }
800:
801: 802: 803: 804: 805: 806: 807:
808: public function dropTable($tableName=null) {
809: self::$logger->debug('>>dropTable()');
810:
811: if(method_exists($this, 'before_dropTable_callback'))
812: $this->before_dropTable_callback();
813:
814: global $config;
815:
816: $provider = AlphaDAOProviderFactory::getInstance($config->get('db.provider.name'), $this);
817: $provider->dropTable($tableName);
818:
819: if(method_exists($this, 'after_dropTable_callback'))
820: $this->after_dropTable_callback();
821:
822: self::$logger->debug('<<dropTable');
823: }
824:
825: 826: 827: 828: 829: 830: 831: 832:
833: public function addProperty($propName) {
834: self::$logger->debug('>>addProperty(propName=['.$propName.'])');
835:
836: global $config;
837:
838: if(method_exists($this, 'before_addProperty_callback'))
839: $this->before_addProperty_callback();
840:
841: $provider = AlphaDAOProviderFactory::getInstance($config->get('db.provider.name'), $this);
842: $provider->addProperty($propName);
843:
844: if(method_exists($this, 'after_addProperty_callback'))
845: $this->after_addProperty_callback();
846:
847: self::$logger->debug('<<addProperty');
848: }
849:
850: 851: 852: 853: 854: 855:
856: public function populateFromPost($filterAll=false) {
857: self::$logger->debug('>>populateFromPost(filterAll=['.$filterAll.'])');
858:
859: if(method_exists($this, 'before_populateFromPost_callback'))
860: $this->before_populateFromPost_callback();
861:
862:
863: $reflection = new ReflectionClass(get_class($this));
864: $properties = $reflection->getProperties();
865:
866: foreach($properties as $propObj) {
867: $propName = $propObj->name;
868:
869: if(!in_array($propName, $this->defaultAttributes) && !in_array($propName, $this->transientAttributes)) {
870: $propClass = get_class($this->getPropObject($propName));
871:
872: if(isset($_POST[$propName])) {
873:
874: if(mb_strtoupper($propClass) == 'BOOLEAN' && $_POST[$propName] == 'on') {
875: $_POST[$propName] = 1;
876: }
877:
878: if (mb_strtoupper($propClass) != 'DATE' && mb_strtoupper($propClass) != 'TIMESTAMP') {
879: if($filterAll) {
880: $this->getPropObject($propName)->setValue(InputFilter::encode($_POST[$propName], false));
881: }else{
882: if(mb_strtoupper($propClass) == 'TEXT' && !$this->getPropObject($propName)->getAllowHTML())
883: $this->getPropObject($propName)->setValue(InputFilter::encode($_POST[$propName], false));
884: else
885: $this->getPropObject($propName)->setValue(InputFilter::encode($_POST[$propName], true));
886: }
887: }else{
888: if($filterAll)
889: $this->getPropObject($propName)->populateFromString(InputFilter::encode($_POST[$propName], false));
890: else
891: $this->getPropObject($propName)->populateFromString(InputFilter::encode($_POST[$propName], true));
892: }
893: }
894: }
895: if ($propName == 'version_num' && isset($_POST['version_num']))
896: $this->version_num->setValue($_POST['version_num']);
897: }
898: if(method_exists($this, 'after_populateFromPost_callback'))
899: $this->after_populateFromPost_callback();
900:
901: self::$logger->debug('<<populateFromPost');
902: }
903:
904: 905: 906: 907: 908: 909:
910: public function populateFromArray($hashArray) {
911: self::$logger->debug('>>populateFromArray(hashArray=['.print_r($hashArray, true).'])');
912:
913:
914: $reflection = new ReflectionClass(get_class($this));
915: $properties = $reflection->getProperties();
916:
917: foreach($properties as $propObj) {
918: $propName = $propObj->name;
919:
920: if(!in_array($propName, $this->defaultAttributes) && !in_array($propName, $this->transientAttributes)) {
921: $propClass = get_class($this->getPropObject($propName));
922:
923: if(isset($hashArray[$propName])) {
924:
925: if (mb_strtoupper($propClass) != 'DATE' && mb_strtoupper($propClass) != 'TIMESTAMP')
926: $this->getPropObject($propName)->setValue($hashArray[$propName]);
927: else
928: $this->getPropObject($propName)->populateFromString($hashArray[$propName]);
929: }
930: }
931:
932: if ($propName == 'version_num' && isset($hashArray['version_num']))
933: $this->version_num->setValue($hashArray['version_num']);
934: }
935:
936: self::$logger->debug('<<populateFromArray');
937: }
938:
939: 940: 941: 942: 943: 944: 945:
946: public function getMAX() {
947: self::$logger->debug('>>getMAX()');
948:
949: if(method_exists($this, 'before_getMAX_callback'))
950: $this->before_getMAX_callback();
951:
952: global $config;
953:
954: $provider = AlphaDAOProviderFactory::getInstance($config->get('db.provider.name'), $this);
955: $max = $provider->getMAX();
956:
957: if(method_exists($this, 'after_getMAX_callback'))
958: $this->after_getMAX_callback();
959:
960: self::$logger->debug('<<getMAX ['.$max.']');
961: return $max;
962: }
963:
964: 965: 966: 967: 968: 969: 970: 971: 972:
973: public function getCount($attributes=array(), $values=array()) {
974: self::$logger->debug('>>getCount(attributes=['.var_export($attributes, true).'], values=['.var_export($values, true).'])');
975:
976: if(method_exists($this, 'before_getCount_callback'))
977: $this->before_getCount_callback();
978:
979: global $config;
980:
981: if(!is_array($attributes) || !is_array($values)) {
982: throw new IllegalArguementException('Illegal arrays attributes=['.var_export($attributes, true).'] and values=['.var_export($values, true).'] provided to loadAllByAttributes');
983: }
984:
985: $provider = AlphaDAOProviderFactory::getInstance($config->get('db.provider.name'), $this);
986: $count = $provider->getCount($attributes, $values);
987:
988: if(method_exists($this, 'after_getCount_callback'))
989: $this->after_getCount_callback();
990:
991: self::$logger->debug('<<getCount ['.$count.']');
992: return $count;
993: }
994:
995: 996: 997: 998: 999: 1000: 1001: 1002:
1003: public function getHistoryCount() {
1004: self::$logger->debug('>>getHistoryCount()');
1005:
1006: if(method_exists($this, 'before_getHistoryCount_callback'))
1007: $this->before_getHistoryCount_callback();
1008:
1009: global $config;
1010:
1011: $provider = AlphaDAOProviderFactory::getInstance($config->get('db.provider.name'), $this);
1012: $count = $provider->getHistoryCount();
1013:
1014: if(method_exists($this, 'after_getHistoryCount_callback'))
1015: $this->after_getHistoryCount_callback();
1016:
1017: self::$logger->debug('<<getHistoryCount ['.$count.']');
1018: return $count;
1019: }
1020:
1021: 1022: 1023: 1024: 1025: 1026: 1027: 1028:
1029: public function getID() {
1030: self::$logger->debug('>>getID()');
1031: $oid = str_pad($this->OID, 11, '0', STR_PAD_LEFT);
1032: self::$logger->debug('<<getID ['.$oid.']');
1033: return $oid;
1034: }
1035:
1036: 1037: 1038: 1039: 1040: 1041: 1042:
1043: public final function getOID() {
1044: if(self::$logger == null)
1045: self::$logger = new Logger('AlphaDAO');
1046: self::$logger->debug('>>getOID()');
1047: $oid = str_pad($this->OID, 11, '0', STR_PAD_LEFT);
1048: self::$logger->debug('<<getOID ['.$oid.']');
1049: return $oid;
1050: }
1051:
1052: 1053: 1054: 1055: 1056: 1057:
1058: public function getVersionNumber() {
1059: self::$logger->debug('>>getVersionNumber()');
1060: self::$logger->debug('<<getVersionNumber ['.$this->version_num.']');
1061: return $this->version_num;
1062: }
1063:
1064: 1065: 1066: 1067: 1068: 1069:
1070: protected function setEnumOptions() {
1071: self::$logger->debug('>>setEnumOptions()');
1072:
1073: if(method_exists($this, 'before_setEnumOptions_callback'))
1074: $this->before_setEnumOptions_callback();
1075:
1076: global $config;
1077:
1078: $provider = AlphaDAOProviderFactory::getInstance($config->get('db.provider.name'), $this);
1079: try {
1080: $provider->setEnumOptions();
1081: }catch (NotImplementedException $e) {
1082: self::$logger->info($e->getMessage());
1083: }
1084:
1085: self::$logger->debug('<<setEnumOptions');
1086: }
1087:
1088: 1089: 1090: 1091: 1092: 1093: 1094: 1095: 1096: 1097: 1098: 1099:
1100: public function get($prop, $noChildMethods = false) {
1101: if(self::$logger == null)
1102: self::$logger = new Logger('AlphaDAO');
1103:
1104: self::$logger->debug('>>get(prop=['.$prop.'], noChildMethods=['.$noChildMethods.'])');
1105:
1106: if(method_exists($this, 'before_get_callback'))
1107: $this->before_get_callback();
1108:
1109: if(empty($prop))
1110: throw new IllegalArguementException('Cannot call get with empty $prop arguement!');
1111:
1112:
1113: if(!$noChildMethods && method_exists($this, 'get'.ucfirst($prop))) {
1114: if(method_exists($this, 'after_get_callback'))
1115: $this->after_get_callback();
1116:
1117: self::$logger->debug('<<get ['.eval('return print_r($this->get'.ucfirst($prop).'(), true);').'])');
1118: return eval('return $this->get'.ucfirst($prop).'();');
1119: }else{
1120:
1121: if(isset($this->$prop) && is_object($this->$prop) && method_exists($this->$prop, 'getValue')) {
1122: if(method_exists($this, 'after_get_callback'))
1123: $this->after_get_callback();
1124:
1125:
1126: self::$logger->debug('<<get ['.$this->$prop->getValue().'])');
1127: return $this->$prop->getValue();
1128: }elseif(isset($this->$prop)) {
1129: if(method_exists($this, 'after_get_callback'))
1130: $this->after_get_callback();
1131:
1132:
1133: self::$logger->debug('<<get ['.print_r($this->$prop, true).'])');
1134: return $this->$prop;
1135: }else{
1136: throw new AlphaException('Could not access the property ['.$prop.'] on the object of class ['.get_class($this).']');
1137: self::$logger->debug('<<get [false])');
1138: return false;
1139: }
1140: }
1141: }
1142:
1143: 1144: 1145: 1146: 1147: 1148: 1149: 1150: 1151: 1152: 1153: 1154:
1155: public function set($prop, $value, $noChildMethods = false) {
1156: self::$logger->debug('>>set(prop=['.$prop.'], $value=['.print_r($value, true).'], noChildMethods=['.$noChildMethods.'])');
1157:
1158: if(method_exists($this, 'before_set_callback'))
1159: $this->before_set_callback();
1160:
1161:
1162: if(!$noChildMethods && method_exists($this, 'set'.ucfirst($prop))) {
1163: if(method_exists($this, 'after_set_callback'))
1164: $this->after_set_callback();
1165:
1166: eval('$this->set'.ucfirst($prop).'($value);');
1167: }else{
1168:
1169: if(isset($this->$prop)) {
1170: if(method_exists($this, 'after_set_callback'))
1171: $this->after_set_callback();
1172:
1173:
1174: if (is_object($this->$prop) && get_class($this->$prop) != false) {
1175: if (mb_strtoupper(get_class($this->$prop)) != 'DATE' && mb_strtoupper(get_class($this->$prop)) != 'TIMESTAMP') {
1176: $this->$prop->setValue($value);
1177: }else{
1178:
1179: $this->$prop->populateFromString($value);
1180: }
1181: }else{
1182:
1183: $this->$prop = $value;
1184: }
1185: }else{
1186: throw new AlphaException('Could not set the property ['.$prop.'] on the object of the class ['.get_class($this).']. Property may not exist, or else does not have a setValue() method and is private or protected.');
1187: }
1188: }
1189: self::$logger->debug('<<set');
1190: }
1191:
1192: 1193: 1194: 1195: 1196: 1197: 1198: 1199: 1200:
1201: public function getPropObject($prop) {
1202: self::$logger->debug('>>getPropObject(prop=['.$prop.'])');
1203:
1204: if(method_exists($this, 'before_getPropObject_callback'))
1205: $this->before_getPropObject_callback();
1206:
1207:
1208: $reflection = new ReflectionClass(get_class($this));
1209: $properties = $reflection->getProperties();
1210:
1211:
1212: $attribute = new ReflectionProperty(get_class($this), $prop);
1213:
1214: if($attribute->isPrivate()) {
1215: if(method_exists($this, 'after_getPropObject_callback'))
1216: $this->after_getPropObject_callback();
1217:
1218: self::$logger->debug('<<getPropObject [false]');
1219: return false;
1220: }
1221:
1222: foreach($properties as $propObj) {
1223: $propName = $propObj->name;
1224:
1225: if($prop == $propName) {
1226: if(method_exists($this, 'after_getPropObject_callback'))
1227: $this->after_getPropObject_callback();
1228:
1229: self::$logger->debug('<<getPropObject ['.var_export($this->$prop, true).']');
1230: return $this->$prop;
1231: }
1232: }
1233: throw new IllegalArguementException('Could not access the property object ['.$prop.'] on the object of class ['.get_class($this).']');
1234: self::$logger->debug('<<getPropObject [false]');
1235: return false;
1236: }
1237:
1238: 1239: 1240: 1241: 1242: 1243: 1244: 1245:
1246: public function checkTableExists($checkHistoryTable = false) {
1247: self::$logger->debug('>>checkTableExists()');
1248:
1249: if(method_exists($this, 'before_checkTableExists_callback'))
1250: $this->before_checkTableExists_callback();
1251:
1252: global $config;
1253:
1254: $provider = AlphaDAOProviderFactory::getInstance($config->get('db.provider.name'), $this);
1255: $tableExists = $provider->checkTableExists($checkHistoryTable);
1256:
1257: if(method_exists($this, 'after_checkTableExists_callback'))
1258: $this->after_checkTableExists_callback();
1259:
1260: self::$logger->debug('<<checkTableExists ['.$tableExists.']');
1261: return $tableExists;
1262: }
1263:
1264: 1265: 1266: 1267: 1268: 1269: 1270: 1271: 1272: 1273:
1274: public static function checkBOTableExists($BOClassName, $checkHistoryTable = false) {
1275: if(self::$logger == null)
1276: self::$logger = new Logger('AlphaDAO');
1277: self::$logger->debug('>>checkBOTableExists(BOClassName=['.$BOClassName.'])');
1278:
1279: global $config;
1280:
1281: require_once $config->get('app.root').'alpha/model/'.$config->get('db.provider.name').'.inc';
1282: eval('$tableExists = '.$config->get('db.provider.name').'::checkBOTableExists($BOClassName, $checkHistoryTable);');
1283:
1284: self::$logger->debug('<<checkBOTableExists ['.($tableExists ? 'true' : 'false').']');
1285: return $tableExists;
1286: }
1287:
1288: 1289: 1290: 1291: 1292: 1293: 1294: 1295:
1296: public function checkTableNeedsUpdate() {
1297: self::$logger->debug('>>checkTableNeedsUpdate()');
1298:
1299: global $config;
1300:
1301: if(method_exists($this, 'before_checkTableNeedsUpdate_callback'))
1302: $this->before_checkTableNeedsUpdate_callback();
1303:
1304: $tableExists = $this->checkTableExists();
1305:
1306: if (!$tableExists) {
1307: self::$logger->debug('<<checkTableNeedsUpdate [true]');
1308: return true;
1309: }else{
1310:
1311: $provider = AlphaDAOProviderFactory::getInstance($config->get('db.provider.name'), $this);
1312: $updateRequired = $provider->checkTableNeedsUpdate();
1313:
1314: if(method_exists($this, 'after_checkTableNeedsUpdate_callback'))
1315: $this->after_checkTableNeedsUpdate_callback();
1316:
1317: self::$logger->debug('<<checkTableNeedsUpdate ['.$updateRequired.']');
1318: return $updateRequired;
1319: }
1320: }
1321:
1322: 1323: 1324: 1325: 1326: 1327: 1328: 1329:
1330: public function findMissingFields() {
1331: self::$logger->debug('>>findMissingFields()');
1332:
1333: global $config;
1334:
1335: if(method_exists($this, 'before_findMissingFields_callback'))
1336: $this->before_findMissingFields_callback();
1337:
1338: $provider = AlphaDAOProviderFactory::getInstance($config->get('db.provider.name'), $this);
1339: $missingFields = $provider->findMissingFields();
1340:
1341: if(method_exists($this, 'after_findMissingFields_callback'))
1342: $this->after_findMissingFields_callback();
1343:
1344: self::$logger->debug('<<findMissingFields ['.var_export($missingFields, true).']');
1345: return $missingFields;
1346: }
1347:
1348: 1349: 1350: 1351: 1352: 1353: 1354:
1355: public function getTableName() {
1356: self::$logger->debug('>>getTableName()');
1357:
1358: eval('$TABLE_NAME = '.get_class($this).'::TABLE_NAME;');
1359:
1360: if(!empty($TABLE_NAME)) {
1361: self::$logger->debug('<<getTableName ['.$TABLE_NAME.']');
1362: return $TABLE_NAME;
1363: }else{
1364: throw new AlphaException('Error: no TABLE_NAME constant set for the class '.get_class($this));
1365: self::$logger->debug('<<getTableName []');
1366: return '';
1367: }
1368: }
1369:
1370: 1371: 1372: 1373: 1374: 1375:
1376: public function getCreatorId() {
1377: self::$logger->debug('>>getCreatorId()');
1378: self::$logger->debug('<<getCreatorId ['.$this->created_by.']');
1379: return $this->created_by;
1380: }
1381:
1382: 1383: 1384: 1385: 1386: 1387:
1388: public function getUpdatorId() {
1389: self::$logger->debug('>>getUpdatorId()');
1390: self::$logger->debug('<<getUpdatorId ['.$this->updated_by.']');
1391: return $this->updated_by;
1392: }
1393:
1394: 1395: 1396: 1397: 1398: 1399:
1400: public function getCreateTS() {
1401: self::$logger->debug('>>getCreateTS()');
1402: self::$logger->debug('<<getCreateTS ['.$this->created_ts.']');
1403: return $this->created_ts;
1404: }
1405:
1406: 1407: 1408: 1409: 1410: 1411:
1412: public function getUpdateTS() {
1413: self::$logger->debug('>>getUpdateTS()');
1414: self::$logger->debug('<<getUpdateTS ['.$this->updated_ts.']');
1415: return $this->updated_ts;
1416: }
1417:
1418: 1419: 1420: 1421: 1422: 1423:
1424: public function markTransient($attributeName) {
1425: self::$logger->debug('>>markTransient(attributeName=['.$attributeName.'])');
1426: self::$logger->debug('<<markTransient');
1427: array_push($this->transientAttributes, $attributeName);
1428: }
1429:
1430: 1431: 1432: 1433: 1434: 1435: 1436:
1437: public function markPersistent($attributeName) {
1438: self::$logger->debug('>>markPersistent(attributeName=['.$attributeName.'])');
1439: self::$logger->debug('<<markPersistent');
1440: $this->transientAttributes = array_diff($this->transientAttributes, array($attributeName));
1441: }
1442:
1443: 1444: 1445: 1446: 1447: 1448: 1449: 1450:
1451: protected function markUnique($attribute1Name, $attribute2Name='', $attribute3Name='') {
1452: self::$logger->debug('>>markUnique(attribute1Name=['.$attribute1Name.'], attribute2Name=['.$attribute2Name.'], attribute3Name=['.$attribute3Name.'])');
1453:
1454: if(empty($attribute2Name)) {
1455: array_push($this->uniqueAttributes, $attribute1Name);
1456: }else{
1457:
1458: if($attribute3Name == '')
1459: $attributes = $attribute1Name.'+'.$attribute2Name;
1460: else
1461: $attributes = $attribute1Name.'+'.$attribute2Name.'+'.$attribute3Name;
1462:
1463: array_push($this->uniqueAttributes, $attributes);
1464: }
1465:
1466: self::$logger->debug('<<markUnique');
1467: }
1468:
1469: 1470: 1471: 1472: 1473: 1474:
1475: public function getUniqueAttributes() {
1476: self::$logger->debug('>>getUniqueAttributes()');
1477: self::$logger->debug('<<getUniqueAttributes: ['.print_r($this->uniqueAttributes, true).']');
1478: return $this->uniqueAttributes;
1479: }
1480:
1481: 1482: 1483: 1484: 1485: 1486: 1487:
1488: public function getIndexes() {
1489: self::$logger->debug('>>getIndexes()');
1490:
1491: global $config;
1492:
1493: $provider = AlphaDAOProviderFactory::getInstance($config->get('db.provider.name'), $this);
1494: $indexNames = $provider->getIndexes();
1495:
1496: self::$logger->debug('<<getIndexes ['.print_r($indexNames, true).']');
1497: return $indexNames;
1498: }
1499:
1500: 1501: 1502: 1503: 1504: 1505: 1506: 1507: 1508: 1509:
1510: public function createForeignIndex($attributeName, $relatedClass, $relatedClassAttribute) {
1511: self::$logger->debug('>>createForeignIndex(attributeName=['.$attributeName.'], relatedClass=['.$relatedClass.'], relatedClassAttribute=['.$relatedClassAttribute.']');
1512:
1513: global $config;
1514:
1515: if(method_exists($this, 'before_createForeignIndex_callback'))
1516: $this->before_createForeignIndex_callback();
1517:
1518: AlphaDAO::loadClassDef($relatedClass);
1519: $relatedBO = new $relatedClass;
1520: $tableName = $relatedBO->getTableName();
1521:
1522:
1523: if($this->getTableName() == $tableName) {
1524: self::$logger->debug('<<createForeignIndex');
1525: return;
1526: }
1527:
1528: $provider = AlphaDAOProviderFactory::getInstance($config->get('db.provider.name'), $this);
1529: $provider->createForeignIndex($attributeName, $relatedClass, $relatedClassAttribute);
1530:
1531: if(method_exists($this, 'after_createForeignIndex_callback'))
1532: $this->after_createForeignIndex_callback();
1533:
1534: self::$logger->debug('<<createForeignIndex');
1535: }
1536:
1537: 1538: 1539: 1540: 1541: 1542: 1543: 1544: 1545:
1546: public function createUniqueIndex($attribute1Name, $attribute2Name = '', $attribute3Name = '') {
1547: self::$logger->debug('>>createUniqueIndex(attribute1Name=['.$attribute1Name.'], attribute2Name=['.$attribute2Name.'], attribute3Name=['.$attribute3Name.'])');
1548:
1549: if(method_exists($this, 'before_createUniqueIndex_callback'))
1550: $this->before_createUniqueIndex_callback();
1551:
1552: global $config;
1553:
1554: $provider = AlphaDAOProviderFactory::getInstance($config->get('db.provider.name'), $this);
1555: $provider->createUniqueIndex($attribute1Name, $attribute2Name, $attribute3Name);
1556:
1557: if(method_exists($this, 'after_createUniqueIndex_callback'))
1558: $this->before_createUniqueIndex_callback();
1559:
1560: self::$logger->debug('<<createUniqueIndex');
1561: }
1562:
1563: 1564: 1565: 1566: 1567: 1568:
1569: public function getDataLabels() {
1570: self::$logger->debug('>>getDataLabels()');
1571: self::$logger->debug('<<getDataLabels() ['.var_export($this->dataLabels, true).'])');
1572: return $this->dataLabels;
1573: }
1574:
1575: 1576: 1577: 1578: 1579: 1580: 1581:
1582: public function setDataLabels($labels) {
1583: self::$logger->debug('>>setDataLabels(labels=['.print_r($labels, true).'])');
1584:
1585: if(is_array($labels))
1586: $this->dataLabels = $labels;
1587: else
1588: throw new IllegalArguementException('The value ['.print_r($labels, true).'] provided to setDataLabels() is not a valid array!');
1589:
1590: self::$logger->debug('<<setDataLabels()');
1591: }
1592:
1593: 1594: 1595: 1596: 1597: 1598: 1599: 1600:
1601: public function getDataLabel($att) {
1602: self::$logger->debug('>>getDataLabel(att=['.$att.'])');
1603:
1604: if(in_array($att, array_keys($this->dataLabels))) {
1605: self::$logger->debug('<<getDataLabel ['.$this->dataLabels[$att].'])');
1606: return $this->dataLabels[$att];
1607: }else{
1608: throw new IllegalArguementException('No data label found on the class ['.get_class($this).'] for the attribute ['.$att.']');
1609: self::$logger->debug('<<getDataLabel [])');
1610: return '';
1611: }
1612: }
1613:
1614: 1615: 1616: 1617: 1618: 1619:
1620: public static function getBOClassNames() {
1621: if(self::$logger == null)
1622: self::$logger = new Logger('AlphaDAO');
1623: self::$logger->debug('>>getBOClassNames()');
1624:
1625: global $config;
1626:
1627: $classNameArray = array();
1628:
1629:
1630: if(file_exists($config->get('app.root').'model')) {
1631:
1632: $handle = opendir($config->get('app.root').'model');
1633:
1634:
1635: while (false !== ($file = readdir($handle))) {
1636: if (preg_match("/Object.inc/", $file)) {
1637: $classname = mb_substr($file, 0, -4);
1638:
1639: array_push($classNameArray, $classname);
1640: }
1641: }
1642: }
1643:
1644:
1645:
1646: $handle = opendir($config->get('app.root').'alpha/model');
1647:
1648:
1649: while (false !== ($file = readdir($handle))) {
1650: if (preg_match("/Object.inc/", $file)) {
1651: $classname = mb_substr($file, 0, -4);
1652:
1653: array_push($classNameArray, $classname);
1654: }
1655: }
1656:
1657: asort($classNameArray);
1658: self::$logger->debug('<<getBOClassNames ['.var_export($classNameArray, true).']');
1659: return $classNameArray;
1660: }
1661:
1662: 1663: 1664: 1665: 1666: 1667:
1668: public function getDefaultAttributes() {
1669: self::$logger->debug('>>getDefaultAttributes()');
1670: self::$logger->debug('<<getDefaultAttributes ['.var_export($this->defaultAttributes, true).']');
1671: return $this->defaultAttributes;
1672: }
1673:
1674: 1675: 1676: 1677: 1678: 1679:
1680: public function getTransientAttributes() {
1681: self::$logger->debug('>>getTransientAttributes()');
1682: self::$logger->debug('<<getTransientAttributes ['.var_export($this->transientAttributes, true).']');
1683: return $this->transientAttributes;
1684: }
1685:
1686: 1687: 1688: 1689: 1690: 1691:
1692: public function getPersistentAttributes() {
1693: self::$logger->debug('>>getPersistentAttributes()');
1694:
1695: $attributes = array();
1696:
1697:
1698: $reflection = new ReflectionClass(get_class($this));
1699: $properties = $reflection->getProperties();
1700:
1701: foreach($properties as $propObj) {
1702: $propName = $propObj->name;
1703:
1704:
1705: if(!in_array($propName, $this->transientAttributes)) {
1706: array_push($attributes, $propName);
1707: }
1708: }
1709:
1710: self::$logger->debug('<<getPersistentAttributes ['.var_export($attributes, true).']');
1711: return $attributes;
1712: }
1713:
1714: 1715: 1716: 1717: 1718: 1719:
1720: public function setOID($OID) {
1721: self::$logger->debug('>>setOID(OID=['.$OID.'])');
1722: self::$logger->debug('<<setOID');
1723: $this->OID = $OID;
1724: }
1725:
1726: 1727: 1728: 1729: 1730: 1731:
1732: public function isTransient() {
1733: self::$logger->debug('>>isTransient()');
1734:
1735: if(empty($this->OID) || !isset($this->OID) || $this->OID == '00000000000') {
1736: self::$logger->debug('<<isTransient [true]');
1737: return true;
1738: }else{
1739: self::$logger->debug('<<isTransient [false]');
1740: return false;
1741: }
1742: }
1743:
1744: 1745: 1746: 1747: 1748: 1749:
1750: public function getLastQuery() {
1751: self::$logger->debug('>>getLastQuery()');
1752: self::$logger->debug('<<getLastQuery ['.$this->lastQuery.']');
1753: return $this->lastQuery;
1754: }
1755:
1756: 1757: 1758: 1759: 1760:
1761: private function clear() {
1762: self::$logger->debug('>>clear()');
1763:
1764:
1765: $reflection = new ReflectionClass(get_class($this));
1766: $properties = $reflection->getProperties();
1767:
1768: foreach($properties as $propObj) {
1769: $propName = $propObj->name;
1770: if(!$propObj->isPrivate())
1771: unset($this->$propName);
1772: }
1773:
1774: self::$logger->debug('<<clear');
1775: }
1776:
1777: 1778: 1779: 1780: 1781: 1782:
1783: public function reload() {
1784: self::$logger->debug('>>reload()');
1785:
1786: if(!$this->isTransient()) {
1787: $this->load($this->getOID());
1788: }else{
1789: throw new AlphaException('Cannot reload transient object from database!');
1790: }
1791: self::$logger->debug('<<reload');
1792: }
1793:
1794: 1795: 1796: 1797: 1798: 1799: 1800:
1801: public static function loadClassDef($classname) {
1802: if(self::$logger == null)
1803: self::$logger = new Logger('AlphaDAO');
1804: self::$logger->debug('>>loadClassDef(classname=['.$classname.'])');
1805:
1806: global $config;
1807:
1808: if(file_exists($config->get('app.root').'model/'.$classname.'.inc'))
1809: require_once $config->get('app.root').'model/'.$classname.'.inc';
1810: elseif(file_exists($config->get('app.root').'alpha/model/'.$classname.'.inc'))
1811: require_once $config->get('app.root').'alpha/model/'.$classname.'.inc';
1812: elseif(file_exists($config->get('app.root').'alpha/model/types/'.$classname.'.inc'))
1813: require_once $config->get('app.root').'alpha/model/types/'.$classname.'.inc';
1814: else
1815: throw new IllegalArguementException('The class ['.$classname.'] is not defined anywhere!');
1816:
1817: self::$logger->debug('<<loadClassDef');
1818: }
1819:
1820: 1821: 1822: 1823: 1824: 1825: 1826:
1827: public static function checkClassDefExists($classname) {
1828: if(self::$logger == null)
1829: self::$logger = new Logger('AlphaDAO');
1830: self::$logger->debug('>>checkClassDefExists(classname=['.$classname.'])');
1831:
1832: global $config;
1833:
1834: $exists = false;
1835:
1836: if(file_exists($config->get('app.root').'model/'.$classname.'.inc'))
1837: $exists = true;
1838: if(file_exists($config->get('app.root').'alpha/model/'.$classname.'.inc'))
1839: $exists = true;
1840: if(file_exists($config->get('app.root').'alpha/model/types/'.$classname.'.inc'))
1841: $exists = true;
1842:
1843: self::$logger->debug('<<checkClassDefExists ['.$exists.']');
1844: return $exists;
1845: }
1846:
1847: 1848: 1849: 1850: 1851: 1852: 1853: 1854:
1855: public function checkRecordExists($OID) {
1856: self::$logger->debug('>>checkRecordExists(OID=['.$OID.'])');
1857:
1858: if(method_exists($this, 'before_checkRecordExists_callback'))
1859: $this->before_checkRecordExists_callback();
1860:
1861: global $config;
1862:
1863: $provider = AlphaDAOProviderFactory::getInstance($config->get('db.provider.name'), $this);
1864: $recordExists = $provider->checkRecordExists($OID);
1865:
1866: if(method_exists($this, 'after_checkRecordExists_callback'))
1867: $this->after_checkRecordExists_callback();
1868:
1869: self::$logger->debug('<<checkRecordExists ['.$recordExists.']');
1870: return $recordExists;
1871: }
1872:
1873: 1874: 1875: 1876: 1877: 1878: 1879: 1880: 1881:
1882: public function isTableOverloaded() {
1883: self::$logger->debug('>>isTableOverloaded()');
1884:
1885: global $config;
1886:
1887: $provider = AlphaDAOProviderFactory::getInstance($config->get('db.provider.name'), $this);
1888: $isOverloaded = $provider->isTableOverloaded();
1889:
1890: self::$logger->debug('<<isTableOverloaded ['.$isOverloaded.']');
1891: return $isOverloaded;
1892: }
1893:
1894: 1895: 1896: 1897: 1898: 1899: 1900:
1901: public static function begin($BO = null) {
1902: if(self::$logger == null)
1903: self::$logger = new Logger('AlphaDAO');
1904: self::$logger->debug('>>begin()');
1905:
1906: global $config;
1907:
1908: if(isset($BO))
1909: $provider = AlphaDAOProviderFactory::getInstance($config->get('db.provider.name'), $BO);
1910: else
1911: $provider = AlphaDAOProviderFactory::getInstance($config->get('db.provider.name'), new PersonObject());
1912:
1913: try{
1914: $provider->begin();
1915: }catch (Exception $e) {
1916: throw new AlphaException('Error beginning a new transaction, error is ['.$e->getMessage().']');
1917: }
1918:
1919: self::$logger->debug('<<begin');
1920: }
1921:
1922: 1923: 1924: 1925: 1926: 1927: 1928:
1929: public static function commit($BO = null) {
1930: if(self::$logger == null)
1931: self::$logger = new Logger('AlphaDAO');
1932: self::$logger->debug('>>commit()');
1933:
1934: global $config;
1935:
1936: if(isset($BO))
1937: $provider = AlphaDAOProviderFactory::getInstance($config->get('db.provider.name'), $BO);
1938: else
1939: $provider = AlphaDAOProviderFactory::getInstance($config->get('db.provider.name'), new PersonObject());
1940:
1941: try{
1942: $provider->commit();
1943: }catch (Exception $e) {
1944: throw new FailedSaveException('Error commiting a transaction, error is ['.$e->getMessage().']');
1945: }
1946:
1947: self::$logger->debug('<<commit');
1948: }
1949:
1950: 1951: 1952: 1953: 1954: 1955: 1956:
1957: public static function rollback($BO = null) {
1958: if(self::$logger == null)
1959: self::$logger = new Logger('AlphaDAO');
1960: self::$logger->debug('>>rollback()');
1961:
1962: global $config;
1963:
1964: if(isset($BO))
1965: $provider = AlphaDAOProviderFactory::getInstance($config->get('db.provider.name'), $BO);
1966: else
1967: $provider = AlphaDAOProviderFactory::getInstance($config->get('db.provider.name'), new PersonObject());
1968:
1969: try{
1970: $provider->rollback();
1971: }catch (Exception $e) {
1972: throw new FailedSaveException('Error aborting a transaction, error is ['.$e->getMessage().']');
1973: }
1974:
1975: self::$logger->debug('<<rollback');
1976: }
1977:
1978: 1979: 1980: 1981: 1982: 1983:
1984: public static function isInstalled() {
1985: if(self::$logger == null)
1986: self::$logger = new Logger('AlphaDAO');
1987: self::$logger->debug('>>isInstalled()');
1988:
1989: global $config;
1990:
1991: 1992: 1993: 1994: 1995: 1996:
1997: if(AlphaDAO::checkBOTableExists('PersonObject') && AlphaDAO::checkBOTableExists('RightsObject')) {
1998: self::$logger->debug('<<isInstalled [true]');
1999: return true;
2000: }else{
2001: self::$logger->debug('<<isInstalled [false]');
2002: return false;
2003: }
2004: }
2005:
2006: 2007: 2008: 2009: 2010: 2011:
2012: public function isTagged() {
2013: if(isset($this->taggedAttributes) && isset($this->tags) && $this->tags instanceof Relation)
2014: return true;
2015: else
2016: return false;
2017: }
2018:
2019: 2020: 2021: 2022: 2023: 2024:
2025: public function getTaggedAttributes() {
2026: if($this->isTagged())
2027: return $this->taggedAttributes;
2028: else
2029: return array();
2030: }
2031:
2032: 2033: 2034: 2035: 2036: 2037:
2038: private function setVersion($versionNumber) {
2039: $this->version_num->setValue($versionNumber);
2040: }
2041:
2042: 2043: 2044: 2045: 2046: 2047: 2048: 2049: 2050: 2051:
2052: public function cast($targetClassName, $originalBO) {
2053: AlphaDAO::loadClassDef($targetClassName);
2054:
2055: $BO = new $targetClassName;
2056: $BO->setOID($originalBO->getOID());
2057: $BO->setVersion($originalBO->getVersion());
2058:
2059:
2060: $originalBOreflection = new ReflectionClass(get_class($originalBO));
2061: $originalBOproperties = $originalBOreflection->getProperties();
2062: $newBOreflection = new ReflectionClass($targetClassName);
2063: $newBOproperties = $newBOreflection->getProperties();
2064:
2065:
2066:
2067: if(count($originalBOproperties) < count($newBOproperties)) {
2068:
2069: foreach($originalBOproperties as $propObj) {
2070: $propName = $propObj->name;
2071: if(!in_array($propName, $this->transientAttributes))
2072: $BO->set($propName, $originalBO->get($propName));
2073: }
2074: }else{
2075:
2076: foreach($newBOproperties as $propObj) {
2077: $propName = $propObj->name;
2078: if(!in_array($propName, $this->transientAttributes))
2079: $BO->set($propName, $originalBO->get($propName));
2080: }
2081: }
2082:
2083: return $BO;
2084: }
2085:
2086: 2087: 2088: 2089: 2090: 2091:
2092: public function getFriendlyClassName() {
2093: $name = mb_substr(get_class($this), 0, -6);
2094:
2095: return $name;
2096: }
2097:
2098: 2099: 2100: 2101: 2102: 2103: 2104:
2105: public function hasAttribute($attribute) {
2106: try{
2107: $exists = $this->$attribute;
2108: return true;
2109: }catch(Exception $e) {
2110: return false;
2111: }
2112: }
2113:
2114: 2115: 2116: 2117: 2118:
2119: public function addToCache() {
2120: self::$logger->debug('>>addToCache()');
2121: global $config;
2122:
2123: try {
2124: $cache = AlphaCacheProviderFactory::getInstance($config->get('cache.provider.name'));
2125: $cache->set(get_class($this).'-'.$this->getOID(), $this, 3600);
2126:
2127: }catch(Exception $e) {
2128: self::$logger->error('Error while attempting to store a business object to the ['.$config->get('cache.provider.name').']
2129: instance: ['.$e->getMessage().']');
2130: }
2131:
2132: self::$logger->debug('<<addToCache');
2133: }
2134:
2135: 2136: 2137: 2138: 2139:
2140: public function removeFromCache() {
2141: self::$logger->debug('>>removeFromCache()');
2142: global $config;
2143:
2144: try {
2145: $cache = AlphaCacheProviderFactory::getInstance($config->get('cache.provider.name'));
2146: $cache->delete(get_class($this).'-'.$this->getOID());
2147: }catch(Exception $e) {
2148: self::$logger->error('Error while attempting to remove a business object from ['.$config->get('cache.provider.name').']
2149: instance: ['.$e->getMessage().']');
2150: }
2151:
2152: self::$logger->debug('<<removeFromCache');
2153: }
2154:
2155: 2156: 2157: 2158: 2159: 2160:
2161: public function loadFromCache() {
2162: self::$logger->debug('>>loadFromCache()');
2163: global $config;
2164:
2165: try {
2166: $cache = AlphaCacheProviderFactory::getInstance($config->get('cache.provider.name'));
2167: $BO = $cache->get(get_class($this).'-'.$this->getOID());
2168:
2169: if(!$BO) {
2170: self::$logger->debug('Cache miss on key ['.get_class($this).'-'.$this->getOID().']');
2171: self::$logger->debug('<<loadFromCache: [false]');
2172: return false;
2173: }else{
2174:
2175: $reflection = new ReflectionClass(get_class($this));
2176: $properties = $reflection->getProperties();
2177:
2178: foreach($properties as $propObj) {
2179: $propName = $propObj->name;
2180:
2181:
2182: if(!in_array($propName, $this->transientAttributes)) {
2183: $this->set($propName, $BO->get($propName, true));
2184: }elseif(!$propObj->isPrivate() && isset($this->$propName) && $this->$propName instanceof Relation) {
2185: $prop = $this->getPropObject($propName);
2186:
2187:
2188: if($prop->getRelationType() == 'ONE-TO-MANY') {
2189: $this->set($propObj->name, $this->getOID());
2190: }
2191: }
2192: }
2193:
2194: self::$logger->debug('<<loadFromCache: [true]');
2195: return true;
2196: }
2197: }catch(Exception $e) {
2198: self::$logger->error('Error while attempting to load a business object from ['.$config->get('cache.provider.name').']
2199: instance: ['.$e->getMessage().']');
2200:
2201: self::$logger->debug('<<loadFromCache: [false]');
2202: return false;
2203: }
2204: }
2205:
2206: 2207: 2208: 2209: 2210: 2211:
2212: public function setLastQuery($query) {
2213: self::$logger->sql($query);
2214: $this->lastQuery = $query;
2215: }
2216:
2217: 2218: 2219: 2220: 2221: 2222:
2223: public function __wakeup() {
2224: if(self::$logger == null)
2225: self::$logger = new Logger(get_class($this));
2226: }
2227:
2228: 2229: 2230: 2231: 2232: 2233: 2234:
2235: public function setMaintainHistory($maintainHistory) {
2236: if(!is_bool($maintainHistory))
2237: throw new IllegalArguementException('Non-boolean value ['.$maintainHistory.'] passed to setMaintainHistory method!');
2238:
2239: $this->maintainHistory = $maintainHistory;
2240: }
2241:
2242: 2243: 2244: 2245: 2246: 2247:
2248: public function getMaintainHistory() {
2249: return $this->maintainHistory;
2250: }
2251: }
2252:
2253: ?>