org.netfrag.elib/_unused/Kopie%20von%20objects.php.inc

<?

// ==============================================================
class DSAbstractObject {

  // the type of this object
  var $type;

  // the name of the object-key
  var $objectkey_name;

  // the (virtual) attributes
  var $attributes;
  
  // references to other/new objects
    // a reference to a "DSSession"-object which will be passed in "from outside" by the "DSEngine"
    var $ref_session;
    // a "DataQuery"-object instantiated in the constructor later
    var $ref_dataquery;
    // a reference to a "PDLModelObject"-object, which will be initialized in the constructor from "$ref_session"
    var $ref_pdlModelObject;
    // a reference to a list (array) of "PDLModelObject"-attributes ("PDLModelObjectAttribute"s)
    var $ref_pdlModelObjectAttributes;
  
  // miscellanious other variables

    // some state-information
    var $bool_unbound;        // no binding to database yet
    var $bool_created;         // created for being a new object
    
    var $pdlEventName;
    var $pdlEventName_CurrentObjectOperation;

    // metainfo about this object
    //var $metainfo;

  // ---------------------------------------------------------------------------------------
  function DSAbstractObject($type, $eventIdentifier, &$ref_session) {

    // initialize most important information for an object :-)
    $this->type = $type;
    $this->ref_session =& $ref_session;
    $this->ref_pdlModelObject =& $this->ref_session->pdlengine->getPDLModelObject($type);
    $this->ref_pdlModelObjectAttributes =& $this->ref_pdlModelObject->attributes;
    $this->objectkey_name = $this->ref_pdlModelObject->objectkey;
    
    $this->_initAttributes();
    
    // initialize object-state (-> "this is a new object")
    $this->bool_unbound = 1;
    $this->bool_created = 1;

    $this->pdlEventName = 'retrieve ' . $eventIdentifier;
    $this->pdlEventName_CurrentObjectOperation = '';

    // create a new "DataQuery"-object and store reference
    $this->ref_dataquery =& new DataQuery();

  }


  // ---------------------------------------------------------------------------------------
  function _initAttributes() {
    $attribute_names = array_keys($this->ref_pdlModelObjectAttributes);
    $this->attributes = createHash($attribute_names);
  }

  // ---------------------------------------------------------------------------------------
  function _initializeObjectOperation($eventname) {
    
    // set class-variables
    $this->pdlEventName_CurrentObjectOperation = $eventname;
    
    // get pdl for current event from "PDLModelObject"
    if (!isset($this->ref_pdlModelObject->events[$eventname])) {
      trigger_error("DSDataObject->load(): Could not find PDLModelEvent \"$eventname\" for object-type \"$this->type\"", E_USER_ERROR);
    }
    $unreadySql = $this->ref_pdlModelObject->events[$eventname]->get_unreadySql();
  
    // initialize "DataQuery"s map-part with mapping-informations
    $this->ref_dataquery->setMap($this->ref_pdlModelObjectAttributes);
      
    // initialize "DataQuery"s sql-part with the "unready" sql-statement
    $this->ref_dataquery->setQuery($unreadySql);

  }

  // ---------------------------------------------------------------------------------------
  function _load_startup() {
    
    // if this object is already bound, we will skip loading it again
    // TODO: if not "bool_dirty"
    if (!$this->bool_unbound) { return; }

    // set object-state
    $this->bool_unbound = 0;
    $this->bool_created = 0;

    $this->_initializeObjectOperation($this->pdlEventName);

  }

  // ---------------------------------------------------------------------------------------
  function _save_startup() {
    
    // - - - - - - - - - - - - - - - - - - - - - - - - - - - 
    // determine pdl-event
      $eventname = '';
      // actual insert
      if ($this->bool_unbound && $this->bool_created) {
        $eventname = 'add';
      }
      // actual update
      if (!$this->bool_unbound && !$this->bool_created) {
        $eventname = 'update';
      }

    // if this object is already bound, we will skip loading it again
    // TODO: if not "bool_dirty"
    //if (!$this->bool_unbound) { return; }

    // set object-state
    //$this->bool_unbound = 0;
    //$this->bool_created = 0;

    $this->_initializeObjectOperation($eventname);

  }

  // ---------------------------------------------------------------------------------------
  function _delete_startup() {
    $eventname = 'remove';
    $this->_initializeObjectOperation($eventname);
  }


  // ---------------------------------------------------------------------------------------
  // declares this object as "unbound" (not loaded)
  function reset() {
    $this->bool_unbound = 1;
  }


}


// ==============================================================
class DSDataObject extends DSAbstractObject {


  // ---------------------------------------------------------------------------------------
  function DSDataObject($type, &$ref_session) {

    // debugging
    slog("DSDataObject: new DSDataObject($type)");
    parent::DSAbstractObject($type, 'single', &$ref_session);

  }


  // ---------------------------------------------------------------------------------------
  function load() {

    $this->_load_startup();

    // validate attributes to assure a good object-operation
    if (!$this->_validateAttributesForObjectOperation('load')) {
      print "<font color=\"red\">DSDataObject->_validateAttributesForObjectOperation('load') for \"{$this->type}\" failed.</font><br>";
    }

    // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
    // add criteria-information to the "DataQuery" to limit the result to this single object/entry
    // HACK!!! move this functionality (':') to "...->addCriteria?)
      $this->ref_dataquery->addCriteria(':' . $this->objectkey_name . ' = ' . $this->getObjectKey());
    
    
    // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
    // retrieve data
      
      // execute the "DataQuery"
      $this->ref_dataquery->query();
      
      // get next (first) item of result(s)
      if ($this->ref_dataquery->next()) {
        
        // initialize attributes with loaded values
        $attributes_loaded =& $this->ref_dataquery->getResult();

        // fill ourself with attributes
        $this->fill($attributes_loaded);
        
        return 1;
      }

  }
  

  // ---------------------------------------------------------------------------------------
  function save() {

    $this->_save_startup();

    // catch all vars to save this object
    $this->save_catchAllVars();

    // validate attributes to assure a good object-operation
    if (!$this->_validateAttributesForObjectOperation('save')) {
      print "<font color=\"red\">DSDataObject->_validateAttributesForObjectOperation('save') for \"{$this->type}\" failed.</font><br>";
    }

    // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
    // add criteria-information to the "DataQuery" to limit the result to this single object/entry
    // HACK!!! move this functionality (':') to "...->addCriteria?)
      //$this->ref_dataquery->addCriteria(':' . $this->objectkey_name . ' = ' . $objectkey);
    
    //print $this->ref_dataquery->getSql() . "<br>";
    //print "save<br>";
    //exit;
    
    // - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
    // save data
      
      // execute the "DataQuery"
      $this->ref_dataquery->setData($this->attributes);
      $this->ref_dataquery->query();
      
      // TODO: review this mechanism!
      // patch object-key if this was a create-operation, because new object-keys are provided by the underlying rdbms here
      if ($this->pdlEventName_CurrentObjectOperation == 'add') {
        $this->setObjectKey($this->ref_dataquery->lastInsertId);
      }

  }
  
  function save_catchAllVars() {
    
    global $HTTP_GET_VARS;

    while(list($key, $value) = each($this->attributes)) {
      if (isset($HTTP_GET_VARS[$key])) {
        $this->attributes[$key] = $HTTP_GET_VARS[$key];
      }
    }
    
  }


  // ---------------------------------------------------------------------------------------
  function delete() {

    $this->_delete_startup();
    $this->ref_dataquery->query();

/*
    $eventname = 'remove';

    if (!isset($this->pdlModelObject->events[$eventname])) {
      trigger_error("could not find PDLModelObjectEvent \"$eventname\"", E_USER_ERROR);
    }
    $almost_sql = $this->pdlModelObject->events[$eventname]->getEventPdl();
    $almost_sql .= ';';

    $almost_sql = str_replace(':' . $this->getID_name(), "'" . $this->getID() . "'", $almost_sql);

    $sql = $almost_sql;

    if ($sql) {
      $this->dataquery->setSQL($sql);
      $this->dataquery->query();
    }
*/

  }

  // ---------------------------------------------------------------------------------------
  function fill($attributes_new) {
    
    // save all attribute-names in case the new ones are incomplete
    $attribute_names = array_keys($this->attributes);
    
    // overwrite original attributes with new ones
    $this->attributes = array_merge(createHash($attribute_names), $attributes_new);

    // set object-state
    switch($this->getObjectKey()) {
      case '<undefined>':
        break;
      case '<new>':
        break;
      case '':
        break;
      // yeah, the object-key is set to a valid value, so we declare this object as "bound"
      default:
        $this->bool_unbound = 0;
        break;
    }
    
  }


  function setMetaInfo($metainfo) {
    $this->metainfo = $metainfo;
  }
  
  function unbind() {
    $this->unbound = 1;
  }

  // ---------------------------------------------------------------------------------------
  function _validateAttributesForObjectOperation($operation_mode) {
    
    /*
    object-key-juggling, we must handle a few things:
      - does this object has got object-keys or not?
      - and if it has - are they valid and stuff?
    */

    switch($operation_mode) {
    
      // - - - - - - - - - - - - 
      case 'load':
        //if ($this->hasObjectKey()) {
          $objectkey = $this->getObjectKey();
          // define here what shall happen if an object with key "<undefined>" gets a load-request
          if ($objectkey == '<undefined>') {
            print "<font color=\"red\">Could not load object with object-type \"{$this->type}\", because the object-key \"{$this->objectkey_name}\" was \"undefined\".</font><br>";
            return;
          }
          // define here what shall happen if an object with key "<new>" gets a load-request
          if ($objectkey == '<new>') {
            print "<font color=\"red\">Could not load object with object-type \"{$this->type}\", because the object-key \"{$this->objectkey_name}\" was \"new\".</font><br>";
            return;
          }
        //}
        break;
      
      // - - - - - - - - - - - - 
      case 'save':
        if ($this->hasObjectKey()) {
          $objectkey = $this->getObjectKey();
          // define here what shall happen if an object with key "<undefined>" gets a save-request
          if ($objectkey == '<undefined>') {
            print "<font color=\"red\">Could not save object with object-type \"{$this->type}\", because the object-key \"{$this->objectkey_name}\" was \"undefined\".</font><br>";
            return;
          }
          // define here what shall happen if an object with key "<new>" gets a save-request
          if ($objectkey == '<new>') {
            //print "<font color=\"red\">Could not save object with object-type \"{$this->type}\", because the object-key \"{$this->objectkey_name}\" was \"new\".</font><br>";
            //return;
            // overwrite the value of the objectkey-attribute
            $this->setObjectKey('null');
          }
        }

        break;
      
    }
    
    return 1;

  }
  
  // ---------------------------------------------------------------------------------------
  function _checkAttributeAccess($attribute_name, $access_mode) {

    /*
    remarks for attribute-access-checking: is the following mechanism okay?
    - always (maybe first): check for attribute-existance
    - read-mode:
        - if the object is new (objectkey == '<new>'), return no value
    - write-mode:
        - if the object has no object-key: continue work
        - if the object has got one or more object-key(s):
          - if the object is bound: continue work
          - if the object is not bound: check if all object-keys are set first before accessing other attributes
    */    

    if (!$this->_existsAttribute($attribute_name)) {
      print "<font color=\"red\">Could not access attribute \"$attribute_name\" (operation: \"$access_mode\") in object \"{$this->type}\". Attribute does not exist.</font><br>";
      return 0;
    }
    

    switch ($access_mode) {

      // - - - - - - - - - - - - 
      case 'read':
        // is this a new object?
        if ( $this->getObjectKey() == '<new>' ) {
          //return $this->_getAttribute($attribute_name);
          return 0;
        }
        break;

      // - - - - - - - - - - - - 
      case 'write':
        // if this object is unbound, just allow access to the object-key(s)
        // this is needed to load a single object in order to set the object-id for loading

        // check for object-key
        if ($this->objectkey_name) {
          if ($this->bool_unbound) {
            if ($attribute_name != $this->objectkey_name) {
              print "<font color=\"red\">Could not access attribute \"$attribute_name\" for setting in object-type \"{$this->type}\", because the object is unbound, not new, ";
              print "and \"$attribute_name\" is not the object-key.</font><br>";
              return 0;
            }
          }
        } else {
          // object has got no object-key: continue work
        }
    
        break;
    }
    
    return 1;
  }
  
  // ---------------------------------------------------------------------------------------
  function get($attribute_name) {

    // debugging
    slog("DSDataObject: get($attribute_name)");

    // attribute-access!?
    if (!$this->_checkAttributeAccess($attribute_name, 'read')) { return; }

    // is this object unbound? if yes, do an implicit load!
    if ($this->bool_unbound) {
      $this->load();
    }

    // TODO: other DataCollections (for "Associations"-functionality)
    //$retval = '';

    // HACK: this comparison doesn't ensure completely if an attribute-value is set or not ( imagine "0" (zero)!!! )
    if ( $retval = $this->_getAttribute($attribute_name) ) {
      return $retval;
    }

  }
  
  // ---------------------------------------------------------------------------------------
  function set($attribute_name, $value) {
    
    // attribute-access!?
    if (!$this->_checkAttributeAccess($attribute_name, 'write')) { return; }

    slog("DSDataObject: set($attribute_name, $value)");
    // TODO (MUST): other DataCollections

    if (isset($this->metainfo[$attribute_name])) {
      switch ($this->metainfo[$attribute_name]['type']) {
        case 'date':
          // modify date from english/american format to german one
          $value = join('-', array_reverse( split('.', $value) ));
          break;
      }
    }

    $this->_setAttribute($attribute_name, $value);
  }

  // ---------------------------------------------------------------------------------------
  function getAll_old() {
    slog("DSDataObject: getAll()");
    return $this->attributes;
  }
  
  function setAll_old($attributes) {
    slog("DSDataObject: setAll($attributes)");
    $this->attributes = $attributes;
  }


  // ---------------------------------------------------------------------------------------
  // returns the attribute-name of the object-key
  function getObjectKeyName() {
    // get name of key
    return $this->objectkey_name;
  }  

  // ---------------------------------------------------------------------------------------
  // returns the attribute-value of the object-key
  function getObjectKey() {

    // get value of key
    $objectkey = $this->_getAttribute($this->objectkey_name);

    if ($objectkey) {
      return $objectkey;
    } else {
      // HACK: !?
      //return "<new>";
      return "<undefined>";
    }
  }  

  // ---------------------------------------------------------------------------------------
  // sets the attribute-value of the object-key
  function setObjectKey($value) {
    // set value of key
    $this->_setAttribute($this->objectkey_name, $value);
  }  

  // ---------------------------------------------------------------------------------------
  // has this object an object-key?
  function hasObjectKey() {
    if ($this->objectkey_name) { return 1; }
  }  

  // ---------------------------------------------------------------------------------------
  function _getAttribute($attribute_name) {
    if (isset($this->attributes[$attribute_name])) {
      return $this->attributes[$attribute_name];
    }
  }

  function _setAttribute($attribute_name, $value) {
    $this->attributes[$attribute_name] = $value;
  }
  
  function _existsAttribute($attribute_name) {
    return isset($this->attributes[$attribute_name]);
  }


}


// ==============================================================
// implements a collection of "DSDataObject"s interacting with a DataQuery
class DSDataCollection extends DSAbstractObject {

  // - - - - - - - - - - - - - - - - - - - - - -
  // data which influences the result of this "DSDataCollection"

    // filters we applied to this DataCollection (a hash of "DSFilter"-objects)
    var $filters;
    // the default concatenator for appending the "filters" to a query with already existing criteria-information
    var $filterConcatenator;
  
    // sortorders we applied to this DataCollection (a hash of "DSSortOrder"-objects)
    var $sortorders;
  
  // - - - - - - - - - - - - - - - - - - - - - -
  // miscellanious data

    // paging?
    var $page;

    // the number of results
    var $resultcount;
    
    // var $data;
    //var $metainfo;

  
  // ---------------------------------------------------------------------------------------
  function DSDataCollection($type, &$ref_session) {
    
    // call parent-constructor
    parent::DSAbstractObject($type, 'all', &$ref_session);
    
    // initialize class-variables
    $this->filters = array();
    $this->filterConcatenator = 'AND';
    $this->sortorders = array();
  }

    
  // ---------------------------------------------------------------------------------------
  // creates a new "DSFilter"-object and adds reference to local "filters"-hash
  function &addFilter($filterstring, $logicalOperator = 'AND') {
    slog("DSDataCollection: &addFilter($filterstring)");
    $r_filter = &new DSFilter($filterstring, $logicalOperator);
    $this->filters[] =& $r_filter;
    return $r_filter;
  }
  
  // ---------------------------------------------------------------------------------------
  // clears all filters from local "filters"-hash
  function clearFilters() {
    slog("DSDataCollection: clearFilters()");
    $this->filters = array();
  }


  // ---------------------------------------------------------------------------------------
  // creates a new "DSSortOrder"-object and adds reference to local "sortorders"-hash
  function &addSortOrder($column, $mode) {
    slog("DSDataCollection: &addSortOrder($column, $mode)");
    $r_order =& new DSSortOrder($column, $mode);
    array_push($this->sortorders, &$r_order);
    return $r_order;
  }


  // ---------------------------------------------------------------------------------------
  // limits DataCollection to a certain "page" (for paging of results)
  function &setPage($pagenumber, $pagesize) {
    // debugging
    slog("DSDataCollection: &setPage($pagenumber, $pagesize)");
    $this->page['number'] = $pagenumber;
    $this->page['size'] = $pagesize;
  }
  

  // ---------------------------------------------------------------------------------------
  // loads data into this "DSDataCollection"
  function load() {

    $this->_load_startup();


      // - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
      // 1. process filters
        // $this->filterConcatenator
        if (isset($this->filters) && count($this->filters)) {
          reset($this->filters);
          while($r_filter =& current($this->filters)) {
            if ($strFilter = $r_filter->getParsed()) {
              //$almost_sql_FilterPart .= $strParsed . $sql_concat;
              //$this->ref_dataquery->addCriteria(':' . $this->objectkey_name . ' = ' . $this->getObjectKey());
              $this->ref_dataquery->addCriteria($strFilter, $r_filter->logicalOperator);
            }
            next($this->filters);
          }
          // clear all filters
          $this->filters = array();
        }


      // - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
      // 2. process orders
        if (isset($this->sortorders) && count($this->sortorders)) {
          reset($this->sortorders);
          while($r_order =& current($this->sortorders)) {
            $this->ref_dataquery->addOrder($r_order->getAttribute(), $r_order->getOrderAscDesc());
            next($this->sortorders);
          }
        }
      

      // - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
      // 3. limit?
        if ( isset($this->page['number']) && isset($this->page['size']) ) {
          $nr = $this->page['number'];
          $size = $this->page['size'];
          $offset = $nr * $size;
          //$almost_sql .= " LIMIT $offset, $size";
          $strLimit = "$offset, $size";
          $this->ref_dataquery->addLimit($strLimit);
        }
      

     // fetch data
    $this->ref_dataquery->query();
    $this->resultcount = $this->ref_dataquery->getRowCount();
    $this->ref_dataquery->retrieveMetaInfo();
    //$this->metainfo = $this->dataquery->metainfo;

  }
  
  
  // ---------------------------------------------------------------------------------------
  // iterates to the next "DSDataObject" in the "DSDataCollection"-result and returns it
  function &next() {

    // debugging
    slog("DSDataCollection: &next()");

    // do an implicit load if we are "unbound"
    if ($this->bool_unbound) {
      $this->load();
    }

    // get next item from a "DataQuery"-result
    if ($this->ref_dataquery->next()) {
      $result = $this->ref_dataquery->getResult();
      //$obj =& $this->session->Map2Obj($row, $this->pdlModelObject->getObjectType() );
      //$obj =& $this->session->Map2Obj($row, $this->objecttype_full, $this->pdlEventName, $this->metainfo );
      //$obj->setMetaInfo($this->metainfo);
      $obj =& $this->ref_session->getDataObject($this->type);
      $obj->fill($result);
      //$obj->attributes =& $result;
      //$obj->bool_unbound = 0;
      return $obj;
    }
  }
  

  // ---------------------------------------------------------------------------------------
  // returns the number of results
  function getResultCount() {
    return $this->resultcount;
  }
  
}

?>
MailToCvsAdmin">MailToCvsAdmin	ViewVC Help
Powered by ViewVC 1.1.26