root/trunk/midgard/tools/midrepository/DataWorkFlow.php

<?
// +----------------------------------------------------------------------+
// | MidRepository: Workflow                                              |
// +----------------------------------------------------------------------+
// | Copyright (c) 2003 David Schmitter, Dataflow Solutions GmbH          |
// +----------------------------------------------------------------------+
// | This program is free software; you can redistribute it and/or modify |
// | it under the terms of the GNU General Public License as published    |
// | by the Free Software Foundation; either version 2 of the License,    |
// | or (at your option) any later version.                               |
// |                                                                      |
// | This program is distributed in the hope that it will be useful,      |
// | but WITHOUT ANY WARRANTY; without even the implied warranty of       |
// | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the        |
// | GNU General Public License for more details.                         |
// |                                                                      |
// | You should have received a copy of the GNU General Public License    |
// | along with this program; if not, write to the Free Software          |
// | Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, |
// | USA                                                                  |
// +----------------------------------------------------------------------+
// | Author: David Schmitter <schmitt@dataflow.ch>                        |
// +----------------------------------------------------------------------+
//

require_once('lib/DataflowMidgardVC.php');

define('WF_PROC_TABLE', 'proc');

define('WF_NEEDS_APPROVE', 1);
define('WF_TO_BE_PUBLISHED', 2);
define('WF_PUBLISHED', 3);
define('WF_TO_BE_UNPUBLISHED', 4);
define('WF_UNPUBLISHED', 5);
define('WF_CANCELLED', 6);

define('COMMENT_OK', "OK von ");
define('COMMENT_BACK', "Zurückgegeben von ");
define('COMMENT_PUBLISHED', "Zum Publizieren freigegeben von ");
define('COMMENT_UNPUBLISHED', "Publikation rückgängig gemacht von ");
define('COMMENT_AUTO_PUBLISHED', "Automatisch publiziert");

$GLOBALS['PartLocks'] = array();

/**
 * For use with usort
 */
function mgd_path_child_cmp($p1, $p2) {
  return mgd_path_is_child_of($p1->path, $p2->path);
}
                    

function mgd_path_is_child_of($parent, $child) {
  $parent = preg_replace('/\/lang:[^\/]+/', '', $parent);
  $child = preg_replace('/\/lang:[^\/]+/', '', $child);
  if ($child == $parent) {
    return 0;
  } else if (strstr($child, $parent) == $child) {
    return 1;
  } else {
    return -1;
  }
}

function mgd_path_fits($constraints, $path) {
  preg_match('/\/(([a-z]+?):)?([^\/]*)/', $constraints, $atoms);
  $langspec = strstr($constraints, '/lang:');
  if ($langspec === false) {
    return true;
  } else {
    if (strstr($path, $langspec) == $langspec) {
      return true;
    } else {
      return false;
    }
  }
}

function wfInit() {
  $WFSession = new WorkflowSession();
  VCSessionRegistry::addDefaultVCSession($WFSession);
}

/**
 * Handles configuration and "global" stuff.
 */
class WorkflowSession extends VCSession {
  var $_confPath = "/home/schmitt/local-cvs/midgard-current/workflow/workflow.xml";
  var $_confDoc;
  var $_confCtx;
  var $_mgdPaths;
  var $_mgdUser;
  var $_mgdUserGuid;
  var $_mgdGroups;
  
  /**
   * Construct a WorkflowSession
   * @param string $arrname 
   * @see VCSession
   */
  function WorkflowSession ($arrname = 'WFSessionConf') { 
    $this->VCSession();
    global $$arrname;
    extract($$arrname);
    global $midgard;
    PEAR::setErrorHandling(PEAR_ERROR_CALLBACK, 'handle_pear_error');
    $mgdGroups = mgd_list_memberships($midgard->user);
    while ($mgdGroups and $mgdGroups->fetch()) {
      $this->_mgdGroups[] = preg_replace('/\/lang:.*/','',mgd_get_path(mgd_get_group($mgdGroups->gid)));
    }
    $user = mgd_get_person($midgard->user);
    $userPath = mgd_get_path($user);
    $this->_mgdUser = preg_replace('/\/lang:.*/','',$userPath);
    $this->_mgdUserGuid = $user->guid();
    $this->_confPath = $wfconf['confpath'];
    $conf = file_get_contents ($this->_confPath);
    $this->_confDoc = xmldoc($conf);
    $this->_confCtx = xpath_new_context($this->_confDoc);
  }
  
  function &getVCSession($branch) {
    global $VCSConf;
    if (isset($VCSConf[$branch])) {
      $vcs = &new VCSession(&$VCSConf[$branch]);
      return $vcs;
    } else {
      trigger_error("Branch $branch not configured", E_USER_WARNING);
      return MGD_ERR_ERROR;
    }
  }

  /**
   * Get the matching MgdPath for the given path, i.e. the "range" defined in workflow configuration.
   * @param int $destId the id of the destination branch
   * @param string $path 
   * @return MgdPath $mgdPath 
   */
  function &getMgdPath($destId, $path) {
    $mgdPaths = $this->listMgdPaths($destId);
    if (!is_array($mgdPaths)) {
      trigger_error("No matching path in workflow configuration", E_USER_NOTICE);
      return false;
    }
    usort($mgdPaths, 'mgd_path_child_cmp');
    foreach($mgdPaths as $mgdPath) {
      if (mgd_path_is_child_of($mgdPath->path, $path) > -1 and mgd_path_fits($mgdPath->path, $path)) {
    return $mgdPath;
      }
    }
  }
  
  /**
   * List all MgdPaths defined for the source branch = current branch
   * @return array $mgdPaths
   */
  function listMgdPaths($destId) {
    if (!is_numeric($destId)) {
      trigger_error("param 1 $destId must be numeric", E_USER_WARNING);
      return MGD_ERR_ERROR;
    }
    if (!$this->_mgdPaths[$destId]) {
      $mgdPaths = xpath_eval_expression($this->_confCtx, '//object');
      $list = array();
      if ($mgdPaths) {
    foreach ($mgdPaths->nodeset as $mgdPathNode) {
      $mgdPath = &new MgdPath($this, $mgdPathNode->get_attribute('id'));
      if ($mgdPath->src == $this->_branch->getName() and $mgdPath->dest == $this->getBranchLabel($destId)) {
        $this->_mgdPaths[$destId][] = &$mgdPath;
      }
    }
      }
    }
    return $this->_mgdPaths[$destId];
  }


  /**
   * Checks permission for the current user to do something with the StepDef
   * @param int $stepDefId the id of the StepDef
   * @param bool $auto (optional) if auto or normal permissions should be checked
   * @return bool $ok
   */
  function mayDoStepDef($stepDefId, $auto = false) {
    if (DEBUG) echo "stepDefId: $stepDefId<br>";
    $stepdef = new StepDef($this, $stepDefId);
    if ($auto) {
      if ($stepdef->type == 'auto') {
    if (DEBUG) echo "true!";
    return true;
      } 
    } else {
      if ($stepdef->type == 'auto') {
    return false;
      }
      if (!is_array($stepdef->subStepDefs) and !$stepdef->subStepDefs[0]) {
    return true;
      }
      foreach ($stepdef->subStepDefs as $subStepDef_id) {
    $subStepDef = new SubStepDef($this, $subStepDef_id);
    if ($subStepDef->user_group == 'group') {
      if (array_search($subStepDef->path, $this->_mgdGroups) !== false)  {
        return true;
      }
    } else {
      if (DEBUG) echo $this->_mgdUser . " " . $subStepDef->path . "<br>";
      if ($this->_mgdUser == $subStepDef->path) {
        return true;
      }        
    }
      }
    } 
    return false;
  }
  
     
  /**
   * Lists all pending WorkflowProcs for the current user.
   * @return array $pendingProcIds
   */
  function listPendingProcs() {
    $stepDefs = array();
    $users = xpath_eval_expression($this->_confCtx, '//user');
    if (isset($users->nodeset)) {
      foreach ($users->nodeset as $user) {
    if ($user->get_attribute('path') == $this->_mgdUser) {
      $step = $user->parent_node();
      $stepDefs[] = $step->get_attribute('id');
    }
      }
    }
    $groups = xpath_eval_expression($this->_confCtx, '//group');
    if (isset($groups->nodeset)) {
      foreach ($groups->nodeset as $group) {
    if (array_search($group->get_attribute('path'), $this->_mgdGroups) !== false) {
      $step = $group->parent_node();
      $stepDefs[] = $step->get_attribute('id');
    }
      }
    }
    if (!$stepDefs) {
      return false;
    }
    return $this->_glob_dbh->getCol('SELECT id FROM proc WHERE step_def_id IN (' . implode(',', $stepDefs) . ')');
  }

  
  /**
   * Do stuff as another user. Only root may do that 
   * @param int $newuser the id of the person
   */
  function su($newuser) {
    if (isRoot()) {
      $mgdGroups = mgd_list_memberships($newuser);
      while ($mgdGroups and $mgdGroups->fetch()) {
    $this->_mgdGroups[] = mgd_get_path(mgd_get_group($mgdGroups->gid));
      }
      $user = mgd_get_person($newuser);
      $this->_mgdUser = mgd_get_path($user);
      $this->_mgdUserGuid = $user->guid(); 
      return true;
    } else {
      return MGD_ERR_ACCESS_DENIED;
    }
  } 
  
  function getBranchLabel($id) {
    foreach($GLOBALS['VCSConf'] as $key => $conf) {
      if (isset($conf['vcconf']['cvsbranchid']) and $conf['vcconf']['cvsbranchid'] == $id) {
    return $key;
      }
    }
    trigger_error("No such branch", E_USER_NOTICE);
    return MGD_ERR_ERROR;
    /* 
    return $this->_glob_dbh->getOne("SELECT label FROM branch WHERE id = $id");
    */
  }

  function getUserPath() {
    return $this->_mgdUser;
  }

}

/**
 * Base class.
 */
class WorkflowDefObject  {
  var $ctx;
  var $xmlsnipp;
  var $node;
  var $session;
  var $id;

  function WorkflowDefObject(&$session, $id) {
    $this->session = &$session;
    $this->id = $id;
    $my_result = xpath_eval_expression($session->_confCtx, "//*[@id='" . $id . "']");
    if (!isset($my_result->nodeset) or !isset($my_result->nodeset[0])) {
      trigger_error("Node not found: $id", E_USER_WARNING);
      $this = MGD_ERR_ERROR;
      return;
    }
    $this->node = $my_result->nodeset[0];
    $this->xmlsnipp = $session->_confDoc->dump_node($this->node);
    $doc = xmldoc($this->xmlsnipp);
    $this->ctx = xpath_new_context($doc);
  }

}

/**
 * Represents an <object> in the XML config file.
 */
class MgdPath extends WorkflowDefObject {
  var $procDefs;
  var $path;
  var $src;
  var $dest;
  function MgdPath(&$session, $id) {
    $this->WorkflowDefObject($session, $id);
    $this->path = $this->node->get_attribute('path');
    $parent = $this->node->parent_node();
    $this->src = $parent->get_attribute('src');
    $this->dest = $parent->get_attribute('dest');
    $child = $this->node->first_child();
    while($child) {
      if (is_a($child, 'DomElement')) {
    $this->procDefs[] = $child->get_attribute('procdef');
      }
      $child = $child->next_sibling();
    }
  }

  function listProcDefs($auto = false) {
    $list = array();
    foreach ($this->procDefs as $procDefId) {
      $procDef = new ProcDef($this->session, $procDefId);
      if ($this->session->mayDoStepDef($procDef->stepDefs[0], $auto)) {
    $list[] = $procDef->id;
      }
    }
    return $list;
  }
  
}
/**
 * Represents a <procdef> in the XML config file.
 */
class ProcDef extends WorkflowDefObject {
  var $stepDefs;
  function ProcDef(&$session, $id) {
    $this->WorkflowDefObject($session, $id);
    $child = $this->node->first_child();
    while($child) {
      if (is_a($child, 'DomElement')) {
    $this->stepDefs[] = $child->get_attribute('id');
      }
      $child = $child->next_sibling();
    }
  }
}

/**
 * Represents a <step> in the XML config file.
 */
class StepDef extends WorkflowDefObject { 
  var $subStepDefs;
  var $op;
  var $type;
  function StepDef(&$session, $id) { 
    $this->WorkflowDefObject($session, $id);
    $this->op = $this->node->get_attribute('operator');
    $this->type = $this->node->get_attribute('type');
    $child = $this->node->first_child();
    while($child) {
      if (is_a($child, 'DomElement')) {
    $this->subStepDefs[] = $child->get_attribute('id');
      }
      $child = $child->next_sibling();
    } 
  }

}

/**
 * Represents a <user> / <group> in the XML config file.
 */
class SubStepDef extends WorkflowDefObject {
  var $path;
  var $user_group;
  function SubStepDef(&$session, $id) { 
    $this->WorkflowDefObject($session, $id);
    $this->path = $this->node->get_attribute('path');
    $this->user_group = $this->node->node_name();
  }
}
 
/**
 * Represents a Workflow process.
 */
class WorkflowProc extends MgdVCObject {
  var $_collectionId;
  var $_stepDefId;
  var $_procDefId;
  var $_destId;
  var $_closed;
  var $_table = WF_PROC_TABLE;
 
   /** 
   * Construct a new WorkflowProc
   * @param array $db the new contents of the fields, name => value
   * @param object $wfs the WorkflowSession (optional) omit if you want to use the default WorkflowSession
   * @return object $wfProc
   */
  function WorkflowProc(&$db, $wfs = 0) {
    $this->MgdVCObject(&$wfs);
    $this->_db = &$db;
    $this->_collectionId = &$this->_db['collection_id'];
    $this->_stepDefId = &$this->_db['step_def_id'];
    $this->_procDefId = &$this->_db['proc_def_id'];
    $this->_destId = &$this->_db['dest_id'];
    $this->_srcId = &$this->_db['src_id'];
    $this->_status = &$this->_db['status'];
    $this->_id = &$this->_db['id'];
    $procDef = new ProcDef($this->_vcs, $this->_db['proc_def_id']);
    if ($db['dest_id'] == $db['src_id']) {
      trigger_error("Source and destination branch are the same", E_USER_WARNING);
      return MGD_ERR_ERROR;
    }
    if (!is_array($procDef->stepDefs)) {
      trigger_error("Invalid procdef: No steps", E_USER_WARNING);
      $this = MGD_ERR_ERROR;
      return;
    }
    return;
  }

  /**
   * Static method
   * Start a new WorkflowProc 
   * @param int $procDef id of the procdef / id of the proc
   * @param int $destId: the id of the dest branch 
   * @param string $spec: guid or path
   * @param array $mode @see MgdDeepCollection
   * @param object $wfs the WorkflowSession (optional) omit if you want to use the default WorkflowSession
   * @return object $wfProc
   */
  function &brew($procDefId, $destId, $spec, $mode = 0, $wfs = 0) {
    MgdVCObject::realVcs($wfs);
    $db['src_id'] = $wfs->getBranchId();
    $db['dest_id'] = $destId;
    $db['proc_def_id'] = $procDefId;
    $coll = MgdDeepCollection::brew($spec, $mode, &$wfs);
    if (!is_a($coll, 'MgdCollection')) {
      trigger_error("Can't construct the MgdCollection", E_USER_WARNING);
      return MGD_ERR_ERROR;
    }
    $parts_list = $coll->flatListElements();
    foreach ($parts_list as $part) {
      echo ($part->getPath() . " is part of collection<br>");
      $mgdPart = MgdPart::readByGuid($part->getGuid(), &$wfs);
      $partpath = $mgdPart->getPath();
      $mgdPath = $wfs->getMgdPath($db['dest_id'], $partpath);
      echo $procDefId;
      if (!in_array($procDefId, $mgdPath->procDefs)) {
    trigger_error("Proc cannot be started on object $partpath", E_USER_WARNING);
    return MGD_ERR_ERROR;
      }
    }
    $coll->write();
    $db['collection_id'] = $coll->getId();
    $db['status'] = WF_NEEDS_APPROVE;
    $ret = &new WorkflowProc($db, &$wfs);
    $ret->writeDB();
    $procDef = new ProcDef($wfs, $procDefId);
    $stepDef = new StepDef($wfs, $procDef->stepDefs[0]);
    if ($stepDef->type == 'auto') {
      if (isset($procDef->stepDefs[1])) {
    $ret->addComment(COMMENT_OK . $this->_vcs->getUserPath());
    $ret->_prepare_step($procDef->stepDefs[1]);
      } else {
    $ret->addComment(($stepDef->type == "auto")?(COMMENT_AUTO_PUBLISHED):(COMMENT_PUBLISHED . $this->_vcs->getUserPath()));
    $ret->_setStatus(WF_TO_BE_PUBLISHED);
    $wfs->notifyStatusHandler();
      }
    } else {
      $ret->_prepare_step($procDef->stepDefs[0]);
    }
    return $ret;
  }

  /** 
   * Static method
   * Construct a WorkflowProc from the DB by id 
   * @param int $id 
   * @param object $wfs (optional) omit if you want to use the default WorkflowSession
   * @return object $wfProc
   */
  function &readById($id, $vcs = 0) {
    MgdVCObject::realVcs($vcs);
    $db = DBObject::readDBById($vcs->getGlobDbh(), WF_PROC_TABLE, $id);
    $ret = &new WorkflowProc(&$db, $vcs);
    return $ret;
  }