qemudb/include/maintainer.php

<?php
/*****************************/
/* functions for maintainers */
/*****************************/
require_once(BASE."include/application.php");
require_once(BASE."include/version.php");
require_once(BASE."include/user.php");

//FIXME: when we have php5 move this into the maintainer class as a constant var
define('iNotificationIntervalDays', 7); // days between each notification level

// class that can retrieve the queued entries for a given maintainer instance
class queuedEntries
{
  var $aVersionIds;
  var $aScreenshotIds;
  var $aTestDataIds;

  var $oMaintainer; // the maintainer we are retrieving entries for

  function queuedEntries($oMaintainer)
  {
    $this->oMaintainer = $oMaintainer;

    $this->aVersionIds = array();
    $this->aScreenshotIds = array();
    $this->aTestDataIds = array();
  }

  // returns true if none of the arrays have any entries in them
  function isEmpty()
  {
    if((count($this->aVersionIds) == 0) &&
       (count($this->aScreenshotIds) == 0) &&
       (count($this->aTestDataIds) == 0))
      {
        return true;
      }

    return false;
  }

  function retrieveQueuedEntries()
  {
    $bDebugOutputEnabled = false;

    if($bDebugOutputEnabled)
      echo "retrieveQueuedEntries() starting\n";

    ////////////////////////////////////
    // retrieve a list of versions to check for queued data
    $aVersionsToCheck = array();
    if($this->oMaintainer->bSuperMaintainer)
    {
      if($bDebugOutputEnabled)
        echo "maintainer is super maintainer\n";

      $oApp = new Application($this->oMaintainer->iAppId);

      //TODO: would like to rely on the constructor but we might be a user with 'admin'
      // privileges and that would mean we would end up retrieved queued versions for
      // this application or unqueued versions depending on which user we were
      $aVersions = $oApp->getVersions();

      foreach($aVersions as $oVersion)
      {
        if($bDebugOutputEnabled)
        {
          echo "Processing version: ";
          print_r($oVersion);
        }

        if($oVersion->objectGetState() == 'queued')
        {
          $this->aVersions[] = $oVersion->objectGetId();
        } else // version isn't queued
        {
          // add the unqueued version to the list of versions to check for queued data
          $aVersionsToCheck[] = $oVersion->iVersionId;
        }
      }
    } else // just a normal maintainer
    {
      $aVersionsToCheck[] = $this->oMaintainer->iVersionId;
      if($bDebugOutputEnabled)
        echo "Normal maintainer of version ".$this->oMaintainer->iVersionId."\n";
    }

    // go through all of the verions to see what queued data they have
    foreach($aVersionsToCheck as $iVersionId)
    {
      if($bDebugOutputEnabled)
        echo "Processing iVersionId of ".$iVersionId."\n";
        
      //////////////////
      // queued testdata

      // retrieve queued testdata for this version
      $sQuery = "select * from testResults where versionId = '?' and state = '?'";
      $hResult = query_parameters($sQuery, $iVersionId, 'queued');

      // go through the test results looking for the oldest queued data
      while($oTestingRow = query_fetch_object($hResult))
      {
        if($bDebugOutputEnabled)
          echo "\tQueued TestData found\n";
        $oTestData = new TestData(null, $oTestingRow);

        $this->aTestDataIds[] = $oTestData->objectGetId();
      }
      // queued testdata
      //////////////////


      ////////////////////
      // queued screenshots
      $sQuery = "select * from appData where type = 'screenshot' and versionId = '?' and queued = '?'";
      $hResult = query_parameters($sQuery, $iVersionId, "true");
      while($oScreenshotRow = query_fetch_object($hResult))
      {
        $oScreenshot = new Screenshot(null, $oScreenshotRow);

        $this->aScreenshotIds[] = $oScreenshot->objectGetId();
      }
      // queued screenshots
      //////////////////////
    }
  }
}

// contains the results of a notification update so other logic
// can act on these results
class notificationUpdate
{
  var $sEmail;
  var $sSubject;
  var $sMsg; // contents of the email we will send to the maintainer
  var $iTargetLevel; // the target notification level based upon the
                     // maintiners queued entries

  function notificationUpdate($sEmail, $sSubject, $sMsg, $iTargetLevel)
  {
    $this->sEmail = $sEmail;
    $this->sSubject = $sSubject;
    $this->sMsg = $sMsg;
    $this->iTargetLevel = $iTargetLevel;
  }
}


class maintainer
{
    var $iMaintainerId;
    var $iAppId;
    var $iVersionId;
    var $iUserId;
    var $sMaintainReason;
    var $bSuperMaintainer;
    var $aSubmitTime; //FIXME: should be 'sSubmitTime'
    var $bQueued; //FIXME: Should be sQueued
    var $sReplyText;

    // parameters used in the queued data notification system
    // that lets maintainers know that their applications/versions have
    // queued data for them to process
    var $iNotificationLevel; // the current warning level of this maintainer
    var $sNotificationTime; // the time when we last warned this maintainer

    function maintainer($iMaintainerId = null, $oRow = null)
    {
        // set a default notification level of 0
        $this->iNotificationLevel = 0;
      
        if(!$iMaintainerId && !$oRow)
            return;

        if(!$oRow)
        {
            $sQuery = "SELECT * FROM appMaintainers WHERE maintainerId = '?'";
            $hResult = query_parameters($sQuery, $iMaintainerId);
            if($hResult)
                $oRow = query_fetch_object($hResult);
        }

        if($oRow)
        {
            $this->iMaintainerId = $oRow->maintainerId;
            $this->iAppId = $oRow->appId;
            $this->iVersionId = $oRow->versionId;
            $this->iUserId = $oRow->userId;
            $this->sMaintainReason = $oRow->maintainReason;
            $this->bSuperMaintainer = $oRow->superMaintainer;
            $this->aSubmitTime = $oRow->submitTime;
            $this->bQueued = $oRow->queued;

            $this->iNotificationLevel = $oRow->notificationLevel;
            $this->sNotificationTime = $oRow->notificationTime;
        }
    }

    function create()
    {
        /* user id, appid, and maintain reason must be valid to continue */
        if(!$this->iAppId || !$this->sMaintainReason)
        {
            return NULL;
        }

        if(!$this->iUserId)
            $this->iUserId = $_SESSION['current']->iUserId;

        $oApp = new application($this->iAppId);
        if(!$this->bSuperMaintainer)
            $oVersion = new version($this->iVersionId);

        if($oApp->objectGetState() != 'accepted' ||
           (!$this->bSuperMaintainer && $oVersion->objectGetState() != 'accepted'))
            $this->sQueued = "pending";
        else
            $this->sQueued = $this->mustBeQueued() ? "true" : "false";

        $hResult = query_parameters("INSERT INTO appMaintainers (appId, versionId, ".
                                    "userId, maintainReason, superMaintainer, submitTime, queued) ".
                                    "VALUES ('?', '?', '?', '?', '?', ?, '?')",
                                    $this->iAppId, $this->iVersionId,
                                    $this->iUserId, $this->sMaintainReason,
                                    $this->bSuperMaintainer, "NOW()", $this->sQueued);

        /* this objects id is the insert id returned by the database */
        $this->iMaintainerId = query_appdb_insert_id();

        /* If this is a non-queued maintainer submission, remove the user's non-
           super maintainer entries for the application's versions.  This check is
           also done in unQueue() */
        if(!$this->mustBeQueued() & $this->bSuperMaintainer)
            $this->removeUserFromAppVersions();

        return $hResult;
    }

    function unQueue()
    {
        /* if the user isn't already a supermaintainer of the application and */
        /* if they are trying to become a maintainer and aren't already a maintainer of */
        /* the version, then continue processing the request */

        $oUser = new User($this->iUserId);
        
        if(!$oUser->isSuperMaintainer($this->iAppId) &&
           ((!$this->bSuperMaintainer && !$oUser->isMaintainer($this->iVersionId)) || $this->bSuperMaintainer))
        {
            /* unqueue the maintainer entry */
            $hResult = query_parameters("UPDATE appMaintainers SET queued='false' WHERE userId = '?' AND maintainerId = '?'",
                                        $this->iUserId, $this->iMaintainerId);

            if($hResult)
            {
                $sStatusMessage = "<p>The maintainer was successfully added into the database</p>\n";

                //Send Status Email
                $sEmail = $oUser->sEmail;
                if ($sEmail)
                {
                    if($this->iVersionId)
                    {
                        $oVersion = new Version($this->iVersionId);
                        $sURL = $oVersion->objectMakeUrl();
                        $sName = version::fullName($this->iVersionId);
                    } else
                    {
                        $oApp = new Application($this->iAppId);
                        $sURL = $oApp->objectMakeUrl();
                        $sName = $oApp->sName;
                    }

                    $sSubject =  "Application Maintainer Request Report";
                    $sMsg  = "Your application to be the maintainer of $sName has been accepted.\n";
                    $sMsg .= "$sURL\n";
                    $sMsg .= "$this->sReplyText\n";
                    $sMsg .= "We appreciate your help in making the Application Database better for all users.\n\n";

                    mail_appdb($sEmail, $sSubject ,$sMsg);
                }
            }
        } else
        {
            /* Delete entry, but only if queued */
            query_parameters("DELETE from appMaintainers WHERE userId = '?' AND maintainerId = '?' AND queued = 'true'", $this->iUserId, $this->iMaintainerId);

            if($oUser->isSuperMaintainer($this->iAppId) && !$this->bSuperMaintainer)
                $sStatusMessage = "<p>User is already a super maintainer of this application</p>\n";
            else
                $sStatusMessage = "<p>User is already a maintainer/super maintainer of this application/version</p>\n";
        }

        /* Delete any maintainer entries the user had for the application's versions,
           if this is a super maintainer request */
        if($this->bSuperMaintainer)
            $this->removeUserFromAppVersions();

        return $sStatusMessage;
    }

    function reject()
    {
        $oUser = new User($this->iUserId);
        $sEmail = $oUser->sEmail;
        if ($sEmail)
        {
            $oApp = new Application($oRow->appId);
            $oVersion = new Version($oRow->versionId);
            $sSubject =  "Application Maintainer Request Report";
            $sMsg  = "Your application to be the maintainer of ".$oApp->sName." ".$oVersion->sName." was rejected. ";
            $sMsg .= $this->sReplyText;
            $sMsg .= "";
            $sMsg .= "-The AppDB admins\n";

           mail_appdb($sEmail, $sSubject ,$sMsg);
        }

        //delete main item
        $sQuery = "DELETE from appMaintainers where maintainerId = '?'";
        $hResult = query_parameters($sQuery, $this->iMaintainerId);

        return $hResult;
    }

    function mustBeQueued()
    {
        /* In place for future fine-grained permisson system, only allow admins for now */
        if($_SESSION['current']->hasPriv("admin"))
            return FALSE;
        else
            return TRUE;
    }

    function purge()
    {
        return $this->delete();
    }

    function delete()
    {
        $sQuery = "DELETE from appMaintainers where maintainerId = '?'";
        $hResult = query_parameters($sQuery, $this->iMaintainerId);

        if(!$hResult)
            return FALSE;

        return TRUE;
    }

    function deleteMaintainer($oUser, $iAppId = null, $iVersionId = null)
    {
        /* remove supermaintainer */
        if($iAppId && ($iVersionId == null))
        {
            $superMaintainer = 1;
            $hResult = query_parameters("DELETE FROM appMaintainers WHERE userId = '?'
                                         AND appId = '?' AND superMaintainer = '?'",
                                        $oUser->iUserId, $iAppId, $superMaintainer);
        } else if($iAppId && $iVersionId) /* remove a normal maintainer */
        {
            $superMaintainer = 0;
            $hResult = query_parameters("DELETE FROM appMaintainers WHERE userId = '?'
                                         AND appId = '?' AND versionId = '?' AND superMaintainer = '?'",
                                        $oUser->iUserId, $iAppId, $iVersionId, $superMaintainer);
        } else if(($iAppId == null) && ($iVersionId == null)) /* remove all maintainership by this user */
        {
            $hResult = query_parameters("DELETE FROM appMaintainers WHERE userId = '?'",
                                        $oUser->iUserId);
        }

        if($hResult)
            return true;
        
        return false;
    }

    function deleteMaintainersForVersion($oVersion)
    {
        if(!$oVersion->iVersionId)
            return FALSE;

        $hResult = query_parameters("DELETE from appMaintainers WHERE versionId='?'",
                                    $oVersion->iVersionId);
        return $hResult;
    }

    function deleteMaintainersForApplication($oApp)
    {
        $sQuery = "DELETE from appMaintainers WHERE appId='?'";
        $hResult = query_parameters($sQuery, $oApp->iAppId);
        return $hResult;
    }

    function ObjectGetEntries($bQueued, $bRejected, $iRows = 0, $iStart = 0)
    {
        /* Not implemented */
        if($bRejected)
            return FALSE;

        $sLimit = "";

        /* Should we add a limit clause to the query? */
        if($iRows || $iStart)
        {
            $sLimit = " LIMIT ?,?";

            /* Selecting 0 rows makes no sense, so we assume the user wants to select all of them
               after an offset given by iStart */
            if(!$iRows)
                $iRows = maintainer::objectGetEntriesCount($bQueued, $bRejected);
        }

        /* Excluding requests for queued apps and versions, as these will be
           handled automatically */
        $sQuery = "SELECT * FROM appMaintainers WHERE
            appMaintainers.queued = '?'$sLimit";

        if($bQueued)
        {
            if($_SESSION['current']->hasPriv("admin"))
            {
                if($sLimit)
                {
                    return query_parameters($sQuery, $bQueued ? "true" : "false", $iStart, $iRows);
                } else
                {
                    return query_parameters($sQuery, $bQueued ? "true" : "false");
                }
            } else
            {
                return NULL;
            }
        } else
        {
            if($sLimit)
            {
                return query_parameters($sQuery, $bQueued ? "true" : "false", $iStart, $iRows);
            } else
            {
                return query_parameters($sQuery, $bQueued ? "true" : "false");
            }
        }
    }

    /* retrieve a maintainer object from a row returned by */
    /* ObjectGetEntries() */
    function ObjectGetObjectFromObjectGetEntriesRow($oRow)
    {
        return new maintainer($oRow->maintainerId);
    }

    // returns the number of applications/versions a particular user maintains
    function getMaintainerCountForUser($oUser, $bSuperMaintainer)
    {
        $sQuery = "SELECT count(*) as cnt from appMaintainers WHERE userid = '?' AND superMaintainer = '?'".
                  " AND queued ='?'";
        $hResult = query_parameters($sQuery, $oUser->iUserId, $bSuperMaintainer ? "1" : "0", "false");
        if(!$hResult)
            return 0;
        $oRow = query_fetch_object($hResult);
        return $oRow->cnt;
    }

    /**
     * get the applications and versions that this user maintains 
     */
    function getAppsMaintained($oUser)
    {
        /* retrieve the list of application and order them by application name */
        $hResult = query_parameters("SELECT appMaintainers.appId, versionId, superMaintainer, appName FROM ".
                                    "appFamily, appMaintainers WHERE appFamily.appId = appMaintainers.appId ".
                                    "AND userId = '?' AND appMaintainers.queued = '?' ORDER BY appName",
                                    $oUser->iUserId, "false");
        if(!$hResult || query_num_rows($hResult) == 0)
            return NULL;

        $aAppsMaintained = array();
        $c = 0;
        while($oRow = query_fetch_object($hResult))
        {
            $aAppsMaintained[$c] = array($oRow->appId, $oRow->versionId, $oRow->superMaintainer);
            $c++;
        }

        return $aAppsMaintained;
    }

    function objectGetEntriesCount($bQueued, $bRejected)
    {
        /* Not implemented */
        if($bRejected)
            return FALSE;

        /* Excluding requests for queued apps and versions, as these are handled 
           automatically.  One SELECT for super maintainers, one for maintainers. */
       $sQuery = "SELECT COUNT(maintainerId) as count FROM appMaintainers WHERE
            appMaintainers.queued = '?'";

        if(!($hResult = query_parameters($sQuery, $bQueued ? "true" : "false")))
            return FALSE;

        if($oRow = query_fetch_object($hResult))
            $iCount = $oRow->count;
        else
            $iCount = 0;

        return $iCount;
    }

    /* see how many maintainer entries we have in the database */
    function getMaintainerCount()
    {
        $sQuery = "SELECT count(*) as maintainers FROM appMaintainers where queued='false'";
        $hResult = query_parameters($sQuery);
        $oRow = query_fetch_object($hResult);
        return $oRow->maintainers;
    }

    /* see how many unique maintainers we actually have */
    function getNumberOfMaintainers()
    {
        $hResult = query_parameters("SELECT DISTINCT userId FROM appMaintainers WHERE queued='false';");
        return query_num_rows($hResult);
    }

    function isUserMaintainer($oUser, $iVersionId = null)
    {
        /* if we are a super maintainer, we are a maintainer of this version as well */
        $oVersion = new Version($iVersionId);
        if($oUser->isSuperMaintainer($oVersion->iAppId))
            return true;

        /* otherwise check if we maintain this specific version */
        if($iVersionId)
        {
            $sQuery = "SELECT * FROM appMaintainers WHERE userId = '?' AND versionId = '?' AND queued = '?'";
            $hResult = query_parameters($sQuery, $oUser->iUserId, $iVersionId, "false");
        } else // are we maintaining any version ?
        {
            $sQuery = "SELECT * FROM appMaintainers WHERE userId = '?' AND queued = '?'";
            $hResult = query_parameters($sQuery, $oUser->iUserId, "false");
        }
        if(!$hResult)
            return false;
        
        return query_num_rows($hResult);
    }

    function isUserSuperMaintainer($oUser, $iAppId = null)
    {
        if($iAppId)
        {
            $sQuery = "SELECT * FROM appMaintainers WHERE userid = '?' AND appId = '?' AND superMaintainer = '1' AND queued = '?'";
            $hResult = query_parameters($sQuery, $oUser->iUserId, $iAppId, "false");
        } else /* are we super maintainer of any applications? */
        {
            $sQuery = "SELECT * FROM appMaintainers WHERE userid = '?' AND superMaintainer = '1' AND queued = '?'";
            $hResult = query_parameters($sQuery, $oUser->iUserId, "false");
        }
        if(!$hResult)
            return false;
        return query_num_rows($hResult);
    }

    /* if given an appid or a version id return a handle for a query that has */
    /* the user ids that are maintainers for this particular appid or version id */
    function getMaintainersForAppIdVersionId($iAppId = null, $iVersionId = null)
    {
        $hResult = null;

        if($iVersionId)
        {
            $hResult = query_parameters("SELECT userId from appMaintainers, appVersion
                WHERE
                    appMaintainers.queued = 'false'
                    AND
                    appVersion.versionId = '?'
                    AND
                    (
                        appMaintainers.versionId = appVersion.versionId
                        OR
                        (
                            appMaintainers.appId = appVersion.appId
                            AND superMaintainer = '1'
                        )
                    )", $iVersionId);
        } 
        /*
         * If versionId was not supplied we fetch supermaintainers of application and maintainer of all versions.
         */
        elseif($iAppId)
        {
            $hResult = query_parameters("SELECT userId 
                                 FROM appMaintainers
                                 WHERE appId = '?' AND queued = 'false'",
                                        $iAppId);
        }

        return $hResult;
    }

    /*
     * get the userIds of super maintainers for this appId
     */
    function getSuperMaintainersUserIdsFromAppId($iAppId)
    {
        $sQuery = "SELECT userId FROM ".
            "appMaintainers WHERE appId = '?' " .
            "AND superMaintainer = '1' AND queued='?';";
        $hResult = query_parameters($sQuery, $iAppId, "false");
        $aUserIds = array();
        $c = 0;
        while($oRow = query_fetch_object($hResult))
        {
            $aUserIds[$c] = $oRow->userId;
            $c++;
        }

        return $aUserIds;
    }

    function ObjectGetHeader()
    {
        $oTableRow = new TableRow();
        $oTableRow->AddTextCell("Submission Date");
        $oTableRow->AddTextCell("Application Name");
        $oTableRow->AddTextCell("Version");
        $oTableRow->AddTextCell("Super maintainer?");
        $oTableRow->AddTextCell("Submitter");
        return $oTableRow;
    }

    function ObjectGetTableRow()
    {
        $oUser = new User($this->iUserId);
        $oApp = new Application($this->iAppId);
        $oVersion = new Version($this->iVersionId);

        $oTableRow = new TableRow();

        $oTableRow->AddTextCell(print_date(mysqldatetime_to_unixtimestamp($this->aSubmitTime)));
        $oTableRow->AddTextCell($oApp->objectMakeLink());
        $oTableRow->AddTextCell(($this->bSuperMaintainer) ? "N/A" : $oVersion->objectMakeLink());
        $oTableRow->AddTextCell(($this->bSuperMaintainer) ? "Yes" : "No");
        $oTableRow->AddTextCell($oUser->objectMakeLink());

        $oOMTableRow = new OMTableRow($oTableRow);
        return $oOMTableRow;
    }

    function objectDisplayAddItemHelp($aClean)
    {
        echo "<p>This page is for submitting a request to become an application maintainer.\n";
        echo "An application maintainer is someone who runs the application \n";
        echo "regularly and who is willing to be active in reporting regressions with newer \n";
        echo "versions of Wine and to help other users run this application under Wine.</p>";
        echo "<p>Being an application maintainer comes with new rights and new responsibilities; please be sure to read the <a href=\"".BASE."/help/?sTopic=maintainer_guidelines\">maintainer's guidelines</a> before to proceed.</p> ";
        echo "<p>We ask that all maintainers explain why they want to be an application maintainer,\n";
        echo "why they think they will do a good job and a little about their experience\n";
        echo "with Wine.  This is both to give you time to\n";
        echo "think about whether you really want to be an application maintainer and also for the\n";
        echo "appdb admins to identify people that are best suited for the job.  Your request\n";
        echo "may be denied if there are already a handful of maintainers for this application or if you\n";
        echo "don't have the experience with Wine that is necessary to help other users out.</p>\n";

        if(!$aClean['iVersionId'])
        {
            echo "<p>Super maintainers are just like normal maintainers but they can modify EVERY version of\n";
            echo "this application (and the application itself).  We don't expect you to run every version but at least to help keep\n";
            echo "the forums clean of stale and out-of-date information.</p>\n";

        }
    }

    function ObjectDisplayQueueProcessingHelp()
    {
        echo "<div align=center><table width='90%' border=0 cellpadding=3 cellspacing=0><tr><td>\n\n";
        echo "Please enter an accurate and personalized reply anytime a maintainer request is rejected.\n";
        echo "Its not polite to reject someones attempt at trying to help out without explaining why.\n";
        echo "</td></tr></table></div>\n\n";    
    }

    function canEdit()
    {
        if($_SESSION['current']->hasPriv("admin"))
            return TRUE;

        return FALSE;
    }

    function objectGetCustomVars($sAction)
    {
        switch($sAction)
        {
            case "add":
                return array("iAppId","iVersionId");

            case "addHelp":
                return array("iVersionId");

            default:
                return null;
        }
    }

    function outputEditor($aClean = null)
    {
        if(!$this->iMaintainerId)
        {
            if($aClean['iVersionId'])
            {
                $oVersion = new version($aClean['iVersionId']);
                $iAppId = $oVersion->iAppId;
            } else
            {
                $iAppId = $aClean['iAppId'];
            }

            $oApp = new application($iAppId);

            echo "<table width='100%' border=0 cellpadding=2 cellspacing=0>\n";
            echo "<tr valign=top><td class=color0>";
            echo '<b>Application</b></td><td>'.$oApp->sName;
            echo '</td></tr>',"\n";
            if($aClean['iVersionId'])
            {
                echo "<tr valign=top><td class=color0>";
                echo '<b>Version</b></td><td>'.$oVersion->sName;
                echo '</td></tr>',"\n";
            }

            $iSuperMaintainer = $aClean['iVersionId'] ? 0 : 1;
            echo "<input type=hidden name='iAppId' value={$aClean['iAppId']}>";
            echo "<input type=hidden name='iVersionId' value='{$aClean['iVersionId']}'>";
            echo "<input type=hidden name='iSuperMaintainer' value=$iSuperMaintainer>";

            if($iSuperMaintainer)
                echo '<tr valign=top><td class=color0><b>Why you want to and should<br />be an application super maintainer</b></td><td><textarea name="sMaintainReason" rows=15 cols=70></textarea></td></tr>',"\n";
            else
                echo '<tr valign=top><td class=color0><b>Why you want to and should<br />be an application maintainer</b></td><td><textarea name="sMaintainReason" rows=15 cols=70></textarea></td></tr>',"\n";

            echo '</table>',"\n";
        } else
        {

            //view application details
            echo html_frame_start("New Maintainer Form",600,"",0);
            echo "<table width='100%' border=0 cellpadding=2 cellspacing=0>\n";
            echo "<input type=\"hidden\" name=\"iMaintainerId\" ".
                "value=\"$this->iMaintainerId\" />";

            /* User name */
            $oSubmitter = new user($this->iUserId);
            echo html_tr(array(
                    array("<b>User name</b>", 'style="text-align:right" class="color0"'),
                    $oSubmitter->objectMakeLink()
                            ));

            /**
            * Show the other maintainers of this application, if there are any
            */
            echo '<tr valign=top><td class=color0 style=\'text-align:right\'><b>Other maintainers</b>';
            /* Fetch maintainers and super maintainers */
            $oVersion = new Version($this->iVersionId);
            $aOtherMaintainers = $oVersion->getMaintainersUserIds();
            $aOtherSuperMaintainers =
                Maintainer::getSuperMaintainersUserIdsFromAppId($this->iAppId);

            if($aOtherMaintainers || $aOtherSuperMaintainers)
                $bFoundMaintainers = true;
            else
                $bFoundMaintainers = false;

            echo "<td>\n";
            /* display maintainers for the version */
            if($aOtherMaintainers)
            {
                while(list($index, $iUserId) = each($aOtherMaintainers))
                {
                    $oUser = new User($iUserId);

                    // because Version::getMaintainersUserIds() includes super maintainers
                    // we need to exclude these from the list of maintainers that we are
                    // building
                    if(!maintainer::isUserSuperMaintainer($oUser, $oVersion->iAppId))
                        echo "$oUser->sRealname<br />\n";
                }
            }

            /* display super maintainers for the given app */

            if($aOtherSuperMaintainers)
            {
                while(list($index, $iUserId) = each($aOtherSuperMaintainers))
                {
                    $oUser = new User($iUserId);
                    echo "$oUser->sRealname*<br />\n";
                }
            }

            if(!$bFoundMaintainers)
            {
                echo "No other maintainers";
            }

            echo "</td></tr>\n";

            // Show which other apps the user maintains
            echo '<tr valign="top"><td class="color0" style=\'text-align:right\'><b>This user also maintains these apps:</b></td><td>',"\n";

            $oUser = new User($this->iUserId);
            $aOtherApps = Maintainer::getAppsMaintained($oUser);
            if($aOtherApps)
            {
                while(list($index, list($iAppIdOther, $iVersionIdOther, $bSuperMaintainerOther)) = each($aOtherApps))
                {
                    $oApp = new Application($iAppIdOther);

                    if($bSuperMaintainerOther)
                        echo $oApp->objectMakeLink()."*<br />\n";
                    else
                        echo $oVersion->fullNameLink($iVersionIdOther)."<br />\n";
                }
            } else
            {
                echo "User maintains no other applications";
            }

            echo "</td></tr>\n";

            $oApp = new Application($this->iAppId);
            $oVersion = new Version($this->iVersionId);

            echo "<input type=\"hidden\" name=\"iAppId\" value=\"".$oApp->iAppId."\" />\n";
            echo "<input type=\"hidden\" name=\"iVersionId\" value=\"".$oVersion->iVersionId."\" />\n";

            //app name
            echo '<tr valign=top><td class=color0 style=\'text-align:right\'><b>App Name:</b></td>',"\n";
            echo "<td>".$oApp->objectMakeLink()."</td></tr>\n";

            //version
            if($oVersion->iVersionId)
            {
                echo '<tr valign=top><td class=color0 style=\'text-align:right\'><b>App Version:</b></td>',"\n";
                echo "<td>".$oVersion->objectMakeLink()."</td></tr>\n";
            }

            //maintainReason
            echo '<tr valign=top><td class=color0 style=\'text-align:right\'><b>Maintainer request reason:</b></td>',"\n";
            echo '<td><textarea name="sMaintainReason" rows=10 cols=35>'.$this->sMaintainReason.'</textarea></td></tr>',"\n";
            echo '</table>';

            echo html_frame_end("&nbsp;");
        }
    }

    function ObjectGetId()
    {
        return $this->iMaintainerId;
    }

    function getOutputEditorValues($aClean)
    {
        $this->iAppId = $aClean['iAppId'];
        $this->iVersionId = $aClean['iVersionId'];
        $this->sReplyText = $aClean['sReplyText'];
        $this->sMaintainReason = $aClean['sMaintainReason'];
        $this->bSuperMaintainer = $this->iVersionId ? 0 : 1;

        return TRUE;
    }

    function objectGetItemsPerPage($sState = 'accepted')
    {
        $aItemsPerPage = array(25, 50, 100, 200);
        $iDefaultPerPage = 25;
        return array($aItemsPerPage, $iDefaultPerPage);
    }

    function objectGetChildren($bIncludeDeleted = false)
    {
        /* We have none */
        return array();
    }

    function update()
    {
        /* STUB: No updating possible at the moment */
        return TRUE;
    }

    function getDefaultReply()
    {
        $sReplyTextHelp = "Enter a personalized reason for accepting or rejecting the ".
                          "user's maintainer request here";

        return $sReplyTextHelp;
    }

    function objectGetMailOptions($sAction, $bMailSubmitter, $bParentAction)
    {
        return new mailOptions();
    }

    function objectGetMail($sAction, $bMailSubmitter, $bParentAction)
    {
        $oSubmitter = new user($this->iSubmitterId);

        $sVerb = $this->sQueued == "true" ? "rejected" : "removed";

        if($this->bSuperMaintainer)
        {
            $oApp = new application($this->iAppId);
            $sFor = $oApp->sName;
        } else
        {
            $sFor = version::fullName($this->iVersionId);
        }

        $sMsg = null;
        $sSubject = null;

        if($bMailSubmitter)
        {
            switch($sAction)
            {
                case "delete":
                    $sSubject = "Maintainership for $sFor $sVerb";
                    if($this->sQueued == "true")
                    {
                        $sMsg = "Your request to be a maintainer of '$sFor'".
                                    " has been denied.";
                    } else
                    {
                        $sMsg = "You have been removed as a maintainer of ".
                                    "'$sFor'.";
                    }
                break;
            }
            $aMailTo = null;
        } else
        {
            switch($sAction)
            {
                case "delete":
                    if(!$bParentAction)
                    {
                        $sSubject = "Maintainership for $sFor $sVerb";
                        if($this->bQueued == "false")
                        {
                            $sMsg = $oSubmitter->sRealName." has been removed as a ".
                                        "maintainer of $sFor.";
                        } else
                        {
                            $sMsg = $oSubmitter->sRealName." request to be a maintainer ".
                                        " of $sFor has been rejected.";
                        }
                    }
                break;
            }
            $aMailTo = User::get_notify_email_address_list(null, null);
        }
        return array($sSubject, $sMsg, $aMailTo);
    }

    function objectGetSubmitterId()
    {
        return $this->iUserId;
    }

    function objectHideDelete()
    {
        return TRUE;
    }

    function display()
    {
        /* STUB: There is not much use for this, but it may be implemented later */
        return TRUE;
    }

    function objectMakeUrl()
    {
        /* STUB: There is not much use for this, but it may be implemented later */
        return TRUE;
    }

    function objectMakeLink()
    {
        /* STUB: There is not much use for this, but it may be implemented later */
        return TRUE;
    }

    /* Delete a user's non-super maintainer entries for an application.  This is useful
       to ensure that the user has no maintainer entries for an app he supermaintains */
    function removeUserFromAppVersions()
    {
        $sQuery = "DELETE FROM appMaintainers WHERE
                superMaintainer = '0'
                AND
                appId = '?'
                AND
                userId = '?'";
        $hResult = query_parameters($sQuery, $this->iAppId, $this->iUserId);

        if(!$hResult)
            return FALSE;

        return TRUE;
    }

    function allowAnonymousSubmissions()
    {
        return FALSE;
    }

    function fetchNotificationUpdate()
    {
      $bDebugOutputEnabled = false;

      if($bDebugOutputEnabled)
        echo "notifyMaintainerOfQueuedData()\n";

      // if a maintainer has an non-zero warning level
      // has it been enough days since we last warned them to warrent
      // checking to see if we should warn them again?
      if($this->iNotificationLevel != 0)
      {
        $iLastWarnTime = strtotime($this->sNotificationTime);
        $iLastWarnAgeInSeconds = strtotime("now") - $iLastWarnTime;
                                                                        
        if($bDebugOutputEnabled)
          echo "iLastWarnAgeInSeconds: ".$iLastWarnAgeInSeconds."\n";
 
        // if it hasn't been at least $iNotificationIntervalDays since the last
        // warning we can skip even checking the user
        if($iLastWarnAgeInSeconds < (iNotificationIntervalDays * 24 * 60 * 60))
        {
          if($bDebugOutputEnabled)
            echo "iNotificationIntervalDays has not elapsed, skipping checking the user\n";
          return null;
        }
      }

      if($bDebugOutputEnabled)
        echo "notification level is: ".$this->iNotificationLevel."\n";

      // instantiate the user so we can retrieve particular values
      $oUser = new User($this->iUserId);

      if($bDebugOutputEnabled)
      {
        echo "this->iUserId: ".$this->iUserId."\n";
        print_r($oUser);
      }

      // get the time the user signed up
      // if queued entries have been queued since before the user signed up
      // we can't punish them for this fact
      $iMaintainerSignupTime = strtotime($this->aSubmitTime);

      if($bDebugOutputEnabled)
        echo "iMaintainerSignupTime: ".$iMaintainerSignupTime."\n";

      // store the oldest queued entry
      $iOldestQueuedEntryTime = strtotime("now");

      // construct the subject of the notification email that we may send
      $sSubject = "Notification of queued data for ";
      $sMsg = "";
      $sMsg.= "Hello ".$oUser->sRealname."<".$oUser->sEmail.">".".\n\n";
      $sMsg.= "You are receiving this email to notify you that there is queued data";
      $sMsg.=" for the ";
      if($this->bSuperMaintainer)
      {
        $oApp = new Application($this->iAppId);
        $sSubject.= $oApp->sName;
        $sMsg.='application, '.$oApp->sName.'('.$oApp->objectMakeUrl().'), that you maintain.'."\n\n";
      } else
      {
        $sFullname = version::fullName($this->iVersionId);
        $oVersion = new Version($this->iVersionId);
        $sSubject.= $sFullname;
        $sMsg.='version, '.$sFullname.'('.$oVersion->objectMakeUrl().'), that you maintain.'."\n\n";
      }
      $sSubject.=" ready for your processing";

      // retrieve the queued entries
      $oQueuedEntries = new queuedEntries($this);
      $oQueuedEntries->retrieveQueuedEntries();
      if($oQueuedEntries->isEmpty())
      {
        if($bDebugOutputEnabled)
          echo "No entries, returning\n";

        //no entries, we might as well return here
        return;
      }

      // process each of the queued versions
      foreach($oQueuedEntries->aVersionIds as $iVersionId)
      {
        $oVersion = new Version($iVersionId);
          
        $sMsg .= 'Version '.$sFullname.' ('.$oVersion->objectMakeUrl().'">'.$sFullname.
          ') is queued and ready for processing.';

        $iSubmitTime = strtotime($oVersion->sSubmitTime);

        // is this submission time older than the oldest queued time?
        // if so this is the new oldest time
        if($iSubmitTime < $iOldestQueuedEntryTime)
        {
          $iOldestQueuedEntryTime = $iSubmitTime;
        }
      }

      if(count($oQueuedEntries->aVersionIds) != 0)
      {
        // FIXME: should use a function to generate these urls and use it here and
        // in sidebar_maintainer.php and sidebar_admin.php
        $sMsg = 'Please visit the test data queue ('.APPDB_ROOT."objectManager.php?sClass=version_queue&bIsQueue=true&sTitle=".
          'Version%20Queue) to process queued versions for applications you maintain.'."\n";
      }

      //////////////////
      // queued testdata

      // go through the test results looking for the oldest queued data
      foreach($oQueuedEntries->aTestDataIds as $iTestDataId)
      {
        if($bDebugOutputEnabled)
          echo "Testresult found\n";
        $oTestData = new TestData($iTestDataId);

        $iSubmitTime = strtotime($oTestData->sSubmitTime);
        if($bDebugOutputEnabled)
          echo "iSubmitTime is ".$iSubmitTime."\n";

        // is this submission time older than the oldest queued time?
        // if so this is the new oldest time
        if($iSubmitTime < $iOldestQueuedEntryTime)
        {
          if($bDebugOutputEnabled)
            echo "setting new oldest time\n";

          $iOldestQueuedEntryTime = $iSubmitTime;
        }
      }

      $iTestResultCount = count($oQueuedEntries->aTestDataIds);
      if($iTestResultCount != 0)
      {
        // grammar is slightly different for singular vs. plural
        if($iTestResultCount == 1)
          $sMsg.="There is $iTestResultCount queued test result. ";
        else
          $sMsg.="There are $iTestResultCount queued test results. ";

        // FIXME: should use a function to generate these urls and use it here and
        // in sidebar_maintainer.php and sidebar_admin.php
        $sMsg .= 'Please visit the AppDB Test Data Queue'.
          '('.APPDB_ROOT.'objectManager.php?sClass=testData_queue&'.
          'bIsQueue=true&sTitle=Test%20Results%20Queue)'.
          ' to process queued test data for versions you maintain.'."\n";
      }
      // queued testdata
      //////////////////


      ////////////////////
      // queued screenshots
      foreach($oQueuedEntries->aScreenshotIds as $iScreenshotId)
      {
        $oScreenshot = new Screenshot($iScreenshotId);

        $iSubmitTime = strtotime($oScreenshot->sSubmitTime);

        // is this submission time older than the oldest queued time?
        // if so this is the new oldest time
        if($iSubmitTime < $iOldestQueuedEntryTime)
        {
          $iOldestQueuedEntryTime = $iSubmitTime;
        }
      }

      // if the oldest queue entry time is older than the time the maintainer
      // signed up, use the maintainer signup time as the oldest time
      if($iOldestQueuedEntryTime < $iMaintainerSignupTime)
        $iOldestQueuedEntryTime = $iMaintainerSignupTime;


      // if we found any queued screenshots add the screenshot queue processing link
      // to the email
      if(count($oQueuedEntries->aScreenshotIds) != 0)
      {
        // FIXME: should use a function to generate these urls and use it here and
        // in sidebar_maintainer.php and sidebar_admin.php
        $sMsg.= 'Please visit the screenshot queue(';
        $sMsg.= APPDB_ROOT.'objectManager.php?sClass=screenshot_queue&bIsQueue=true&sTitle=Screenshot%20Queue) ';
        $sMsg.= 'to process queued screenshots for versions you maintain.'."\n";
      }
        
      // queued screenshots
      //////////////////////

      // compute the age in seconds of the oldest entry
      $iAgeInSeconds = strtotime("now") - $iOldestQueuedEntryTime;

      // compute the target warning level based on the age and the notification interval
      // we divide the age by the number of seconds in a day multiplied by the days per notification interval
      $iTargetLevel = (integer)($iAgeInSeconds / (iNotificationIntervalDays * 24 * 60 * 60));

      if($bDebugOutputEnabled)
      {
        echo "iOldestQueuedEntryTime is $iOldestQueuedEntryTime\n";
        echo "iAgeInSeconds is $iAgeInSeconds\n";
        echo "iNotificationIntervalDays is ".iNotificationIntervalDays."\n";
        echo "strtotime(now) is ".strtotime("now")."\n";
        echo "iTargetLevel is ".$iTargetLevel."\n";
      }

      $oNotificationUpdate = new notificationUpdate($oUser->sEmail, $sSubject,
                                                    $sMsg, $iTargetLevel);

      return $oNotificationUpdate;
    }

    // level 0 is from 0 to iNotificationIntervalDays
    // level 1 is from (iNotificationIntervalDays + 1) to (iNotificationIntervalDays * 2)
    // level 2 is from (iNotificationIntervalDays * 2 + 1) to (iNotificationIntervalDays * 3)
    // level 3 is beyond (iNotificationIntervalDays * 3)
    function processNotificationUpdate($oNotificationUpdate)
    {
      $bDebugOutputEnabled = false;

      // if the target level is less than the current level, adjust the current level
      // This takes into account the entries in the users queue that may have been processed
      if($oNotificationUpdate->iTargetLevel < $this->iNotificationLevel)
      {
        if($bDebugOutputEnabled)
          echo "Using iTargetLevel of $oNotificationUpdate->iTargetLevel\n";
        $this->iNotificationLevel = $oNotificationUpdate->iTargetLevel;
      }

      // if the target level is higher than the current level then adjust the
      // current level up by 1
      // NOTE: we adjust up by one because we want to ensure that we go through
      //       notification levels one at a time
      if($oNotificationUpdate->iTargetLevel > $this->iNotificationLevel)
      {
        if($bDebugOutputEnabled)
          echo "Increasing notification level of $this->iNotificationLevel by 1\n";
        $this->iNotificationLevel++;
      }

      switch($this->iNotificationLevel)
      {
      case 0: // lowest level, no notification
        // nothing to do here
        break;
      case 1: // send the first notification
        // nothing to do here, the first notification is just a reminder
        break;
      case 2: // send the second notification, notify them that if the queued entries aren't
              // processed after another $iNotificationIntervalDays that
              // we'll have to remove their maintainership for this application/version
              // so a more active person can fill the spot
        $oNotificationUpdate->sMsg.= "\nThis your second notification of queued entries.";
        $oNotificationUpdate->sMsg.= " If the queued entries are not processsed within";
        $oNotificationUpdate->sMsg.= " the next ".iNotificationIntervalDays. " days we will";
        $oNotificationUpdate->sMsg.= " remove your maintainership for this application/version";
        $oNotificationUpdate->sMsg.= " so a more active person can fill the spot.";
        break;
      case 3: // remove their maintainership and notify the maintainer why we are doing so
        $oNotificationUpdate->sMsg.= "\nThis your third notification of queued entries.";
        $oNotificationUpdate->sMsg.= " Because your queued entries have not been processed";
        $oNotificationUpdate->sMsg.= " after two notifications we are removing your maintainer";
        $oNotificationUpdate->sMsg.= " role for this application/version. Removing inactive";
        $oNotificationUpdate->sMsg.= " maintainers lets us free up slots for other potential";
        $oNotificationUpdate->sMsg.= " maintainers.\n";
        $oNotificationUpdate->sMsg.= " If you are still interested in being a maintainer please";
        $oNotificationUpdate->sMsg.= " submit a maintainer request.";
        $this->delete(); // delete ourselves from the database
        break;
      }
      
      // common end of our message
      $oNotificationUpdate->sMsg.= "\n\nThanks,\n";
      $oNotificationUpdate->sMsg.= "Appdb Admins\n";
      $oNotificationUpdate->sMsg.= "<appdb@winehq.org>";

      // save the notification level and notification time back into the database
      $sQuery = "update appMaintainers set notificationLevel = '?', notificationTime = ?".
        " where maintainerId = '?'";
      query_parameters($sQuery, $this->iNotificationLevel, "NOW()", $this->iMaintainerId);

      //TODO: we probably want to copy the mailing list on each of these emails
      $oNotificationUpdate->sEmail.=" cmorgan@alum.wpi.edu"; // FIXME: for debug append my email address

      // we don't send any emails if the notification level is zero
      if($this->iNotificationLevel == 0)
      {
        if($bDebugOutputEnabled)
          echo "At level 0, no warning issued to ".$oUser->sEmail."\n";
      } else
      {
        if($bDebugOutputEnabled)
        {
          echo "Email: ".$oNotificationUpdate->sEmail."\n";
          echo "Subject: ".$oNotificationUpdate->sSubject."\n";
          echo "Msg: ".$oNotificationUpdate->sMsg."\n\n";
        }

        mail_appdb($oNotificationUpdate->sEmail, $oNotificationUpdate->sSubject,
                   $oNotificationUpdate->sMsg);
      }
    }

    function notifyMaintainerOfQueuedData()
    {
      $oNotificationUpdate = $this->fetchNotificationUpdate();

      // if we have a valid notificationUpdate then process it, otherwise skip it
      if($oNotificationUpdate != NULL)
        $this->processNotificationUpdate($oNotificationUpdate);
    }

    // static method called by the cron maintenance script to notify
    // maintainers of data pending for their applications and versions
    //TODO: php5 make this static when we have php5
    function notifyMaintainersOfQueuedData()
    {
      // retrieve all of the maintainers
      $hResult = maintainer::objectGetEntries(false, false);

      //      echo "Processing ".query_num_rows($hResult)." maintainers\n";

      // notify this user, the maintainer, of queued data, if any exists
      while($oRow = query_fetch_object($hResult))
      {
        $oMaintainer = new maintainer(null, $oRow);
        $oMaintainer->notifyMaintainerOfQueuedData();
      }
    }
}

?>