PHP Data::getRow方法代码示例

function processAdjustUserDataRequest($request)
{
    $prfx = DB_PREFIX;
    $user_row = RequestUtils::testSession($request->sessionID);
    $adjust_user_id = $request->userID;
    $adjust_user_row = Data::getRow(sprintf("SELECT * FROM {$prfx}user WHERE id=%s", Data::quote_smart($adjust_user_id)));
    if (!$adjust_user_row) {
        throwBusinessLogicError(2);
    }
    if ($user_row['user_type'] === 'Participant') {
        throwBusinessLogicError(0);
    }
    if ($user_row['user_type'] === 'ContestAdmin' && $user_row['contest_id'] != $adjust_user_row['contest_id']) {
        throwBusinessLogicError(0);
    }
    $queries = array();
    if (!is_null($request->login)) {
        $queries['login'] = $request->login;
    }
    if (!is_null($request->password)) {
        $queries['password'] = $request->password;
    }
    if (!is_null($request->userData)) {
        $queries['user_data'] = @serialize($request->userData);
    }
    if (!is_null($request->newType)) {
        $queries['user_type'] = $request->newType;
    }
    $q = Data::composeUpdateQuery("user", $queries, sprintf("id=%s", Data::quote_smart($adjust_user_id)));
    Data::submitModificationQuery($q);
    return new AcceptedResponse();
}

function queryForContestDescription($contest_description, $contest_id)
{
    //get current contest settings
    $prfx = DB_PREFIX;
    $row = Data::getRow("SELECT settings FROM {$prfx}contest WHERE id={$contest_id}");
    $settings = Data::_unserialize($row['settings']);
    copyValues($contest_description, $settings);
    RequestUtils::assertContestSettingsIntegrity($settings);
    $col_value = array('settings' => @serialize($settings));
    Data::submitModificationQuery(Data::composeUpdateQuery("contest", $col_value, "id={$contest_id}"));
}

function processDisconnectRequest($request)
{
    $prfx = DB_PREFIX;
    $where = sprintf("WHERE session_id = %s", Data::quote_smart($request->sessionID));
    //TODO think how to implement this more efficient in our architecture
    if (!Data::getRow("SELECT * FROM {$prfx}session {$where}")) {
        throwBusinessLogicError(3);
    }
    Data::submitModificationQuery("DELETE FROM {$prfx}session {$where}");
    return new AcceptedResponse();
}

function processAdjustPluginRequest($request)
{
    $prfx = DB_PREFIX;
    $user_row = RequestUtils::testSession($request->sessionID);
    //authorize
    if ($user_row['user_type'] !== 'SuperAdmin') {
        throwBusinessLogicError(0);
    }
    //test plugin alias
    if (preg_match('/^[\\p{L}0-9 ]+$/', $request->pluginAlias) === 0) {
        throwBusinessLogicError(238);
    }
    $plugin_type = $request->side === 'Client' ? 'client' : 'server';
    //test if there already is such plugin
    $where_clause = sprintf("alias=%s", Data::quote_smart($request->pluginAlias));
    $plugin_row = Data::getRow("SELECT * FROM {$prfx}{$plugin_type}_plugin WHERE {$where_clause}");
    if ($plugin_row) {
        $modify = true;
    } else {
        $modify = false;
    }
    //test all parameters specified
    if (!$modify && is_null($request->description)) {
        $request->description = "";
    }
    if (!$modify && (is_null($request->pluginData) || is_null($request->description))) {
        throwBusinessLogicError(1);
    }
    //TODO test pluginAlias to be secure
    if ($plugin_type === 'client') {
        $ext = '.jar';
    } else {
        $ext = '.php';
    }
    //set file data
    if (!is_null($request->pluginData)) {
        file_put_contents($GLOBALS["dces_dir_{$plugin_type}_plugins"] . '/' . $request->pluginAlias . $ext, $request->pluginData);
    }
    //prepare set plugin description
    $col_value = array();
    if (!is_null($request->description)) {
        $col_value['description'] = $request->description;
    }
    if ($modify) {
        $query = Data::composeUpdateQuery("{$plugin_type}_plugin", $col_value, $where_clause);
    } else {
        $col_value['alias'] = $request->pluginAlias;
        $query = Data::composeInsertQuery("{$plugin_type}_plugin", $col_value);
    }
    Data::submitModificationQuery($query);
    return new AcceptedResponse();
}

function processConnectToContestRequest($request)
{
    $prfx = DB_PREFIX;
    //find user in table
    $row = Data::getRow(sprintf("SELECT {$prfx}user.*, {$prfx}contest.settings\r\n                             FROM {$prfx}user\r\n                             LEFT JOIN {$prfx}contest\r\n                             ON {$prfx}user.contest_id = {$prfx}contest.id\r\n                             WHERE login=%s AND contest_id=%s", Data::quote_smart($request->login), Data::quote_smart($request->contestID)));
    //test if there is at least one user
    if (!$row) {
        throwBusinessLogicError(12);
    }
    //test password
    if ($row['password'] !== $request->password) {
        throwBusinessLogicError(12);
    }
    //get contest settings and contest time
    $settings = Data::_unserialize($row['settings'], null);
    if (is_null($row['contest_start'])) {
        $now = getdate();
        $now = $now[0];
        $q = Data::composeUpdateQuery('user', array('contest_start' => DatePHPToMySQL($now)), "id={$row['id']}");
        Data::submitModificationQuery($q);
        $row['contest_start'] = $now;
    }
    $contest_time = getCurrentContestTime($settings, DateMySQLToPHP($row['contest_start']), DateMySQLToPHP($row['contest_finish']));
    if ($contest_time['interval'] === 'before' && $row['user_type'] === 'Participant') {
        throwBusinessLogicError(19);
    }
    //start new session
    $session_id = RequestUtils::createSession($row['id']);
    //get finish time
    if (is_null($settings)) {
        $finish_time = 0;
    } elseif ($settings->contestTiming->selfContestStart) {
        $finish_time = $row['contest_start'] + 60 * $settings->contestTiming->maxContestDuration;
    } else {
        $finish_time = $settings->finish;
    }
    if (is_null($finish_time)) {
        $finish_time = 0;
    }
    $res = new ConnectToContestResponse();
    $res->sessionID = $session_id;
    $res->finishTime = $finish_time;
    $res->user = new UserDescription();
    $res->user->userID = (int) $row['id'];
    $res->user->login = $request->login;
    $res->user->dataValue = Data::_unserialize($row['user_data'], array());
    $res->user->userType = $row['user_type'];
    return $res;
}

 /**
  * Updates user result for a specified problem
  * @static
  * @param  $user_id id of the user
  * @param  $problem_id id of the problem
  * @param  $choice type of choice, Self of Last
  * @param  $transfer_settings settings of transfer
  * @param  $plugin plugin associated with the problem, needed only when $choice == Best to find best submission     
  * @param  $last_result last result of user if present
  * @return array array with results for results table
  */
 public static function getUserResults($user_id, $problem_id, $choice, $transfer_settings, $plugin, $last_result = null)
 {
     $prfx = DB_PREFIX;
     //get new result
     $all_results_request = "\n                    SELECT result, submission_time\n                    FROM {$prfx}submission_history\n                    WHERE user_id={$user_id}\n                    ORDER BY submission_time DESC\n        ";
     if ($choice === 'Last') {
         if ($last_result) {
             $new_result = $last_result;
         } else {
             //get all rows sorted with descending time, and then get first
             $row = Data::getRow($all_results_request);
             if (!$row) {
                 $new_result = array();
             } else {
                 $new_result = Data::_unserialize($row['result']);
             }
         }
     } else {
         // $choice === 'Best'
         $history_results = array();
         if ($last_result) {
             $history_results[] = $last_result;
         }
         $rows = Data::getRows($all_results_request);
         while ($row = Data::getNextRow($rows)) {
             $history_results[] = $row['result'];
         }
         $num_results = count($history_results);
         if ($num_results == 0) {
             $new_result = array();
         } else {
             $new_result = $history_results[$num_results - 1];
             for ($i = $num_results - 2; $i >= 0; $i--) {
                 if ($plugin->compareResults($history_results[$i], $new_result) === 1) {
                     $new_result = $history_results[$i];
                 }
             }
         }
     }
     $transfer = new ResultsTransfer($transfer_settings);
     return $transfer->convert($new_result);
 }

 public static function testSession($session_id)
 {
     //returns user id, dies absolutely if session is invalid
     $prfx = DB_PREFIX;
     //test session ID to have only alphanumeric characters
     $session_regexp = "^[a-zA-Z0-9_]+\$";
     if (!ereg($session_regexp, $session_id)) {
         throwBusinessLogicError(3);
     }
     //test if there is at least one such user
     $user_row = Data::getRow("SELECT {$prfx}user.*, {$prfx}contest.settings\r\n       FROM {$prfx}session\r\n       INNER JOIN {$prfx}user\r\n       ON {$prfx}session.user_id={$prfx}user.id\r\n       LEFT JOIN {$prfx}contest\r\n       ON {$prfx}user.contest_id={$prfx}contest.id\r\n       WHERE session_id='{$session_id}'");
     if (!$user_row) {
         throwBusinessLogicError(3);
     }
     if (is_null($user_row['settings'])) {
         $user_row['settings'] = serialize(null);
     }
     RequestUtils::$user_row = $user_row;
     //return found user
     return $user_row;
 }

function processRemoveUserRequest($request)
{
    $prfx = DB_PREFIX;
    $user_row = RequestUtils::testSession($request->sessionID);
    $remove_user_id = $request->userID;
    $remove_user_row = Data::getRow(sprintf("SELECT *\r\n                                     FROM {$prfx}user\r\n                                     WHERE id=%s", Data::quote_smart($remove_user_id)));
    if (!$remove_user_row) {
        throwBusinessLogicError(2);
    }
    if ($user_row['user_type'] === 'Participant') {
        throwBusinessLogicError(0);
    }
    if ($user_row['user_type'] === 'ContestAdmin' && $user_row['contest_id'] != $remove_user_row['contest_id']) {
        throwBusinessLogicError(0);
    }
    //remove user $remove_user_id
    $prfx = DB_PREFIX;
    //from 'users' table
    Data::submitModificationQuery(sprintf("DELETE FROM {$prfx}user WHERE id=%s", Data::quote_smart($remove_user_id)));
    Data::submitModificationQuery(sprintf("DELETE FROM {$prfx}session WHERE user_id=%s", Data::quote_smart($remove_user_id)));
    Data::submitModificationQuery(sprintf("DELETE FROM {$prfx}submission_history WHERE user_id=%s", Data::quote_smart($remove_user_id)));
    Data::submitModificationQuery(sprintf("DELETE FROM {$prfx}problem_status WHERE user_id=%s", Data::quote_smart($remove_user_id)));
    return new AcceptedResponse();
}

function processSubmitSolutionRequest($request)
{
    $prfx = DB_PREFIX;
    //get user_id or die, if session is invalid
    $userRow = RequestUtils::testSession($request->sessionID);
    $user_id = $userRow['id'];
    //authorize user for this operation
    // get contest ID
    $user_type = $userRow['user_type'];
    //get problem row
    $problem_row = Data::getRow(sprintf("SELECT * FROM {$prfx}problem WHERE id=%s", Data::quote_smart($request->problemID)));
    if (!$problem_row) {
        throwBusinessLogicError(4);
    }
    //get contest id of a problem
    $problem_contest_id = $problem_row['contest_id'];
    //test if we have rights to submit solution for the contest
    $contest_id = RequestUtils::getRequestedContest($problem_contest_id, $userRow['contest_id'], $user_type);
    if ($contest_id < 0) {
        throwBusinessLogicError(0);
    }
    //get all settings
    $contest_settings = Data::_unserialize($userRow['settings']);
    //test submission time
    $cur_time = getCurrentContestTime($contest_settings, DateMySQLToPHP($userRow['contest_start']), DateMySQLToPHP($userRow['contest_finish']));
    if ($cur_time['interval'] === 'before') {
        throwBusinessLogicError(19);
    }
    if ($cur_time['interval'] === 'after') {
        throwBusinessLogicError(20);
    }
    $problem_settings = Data::_unserialize($problem_row['contest_settings']);
    //test that not all submission attempts were used
    $hist = Data::getRow(sprintf("SELECT COUNT(*) AS cnt FROM {$prfx}submission_history WHERE (problem_id=%s) AND (user_id=%s)", Data::quote_smart($request->problemID), Data::quote_smart($user_id)));
    if ($hist >= getSetting($contest_settings->problemsDefaultSettings->sendCount, $problem_settings->sendCount)) {
        throwBusinessLogicError(21);
    }
    //save submission result in history
    $cur_php_time = getdate();
    $col_value = array();
    $col_value['problem_id'] = $request->problemID;
    $col_value['user_id'] = $user_id;
    $col_value['submission'] = serialize($request->problemResult);
    $col_value['result'] = null;
    //serialize($check_result);
    $col_value['submission_time'] = DatePHPToMySQL($cur_php_time[0]);
    //TODO implement asynchronous plugin
    //get problem and create plugin
    $problem = new Problem(getProblemFile($request->problemID));
    $plugin_alias = $problem->getServerPlugin();
    require_once getServerPluginFile();
    require_once getServerPluginFile($plugin_alias);
    $plugin = new $plugin_alias($problem);
    //check solution
    $last_result = $plugin->checkSolution(Data::getInsertedID(), $request->problemResult);
    $col_value['result'] = serialize($last_result);
    Data::submitModificationQuery(Data::composeInsertQuery('submission_history', $col_value));
    //get result for result table and store in user
    $all_results = Data::_unserialize($userRow['results']);
    $user_result = ResultUtils::getUserResults($user_id, $request->problemID, getSetting($contest_settings->problemsDefaultSettings->tableResultChoice, $problem_settings->tableResultChoice), getSetting($contest_settings->problemsDefaultSettings->resultTransition, $problem_settings->resultTransition), $plugin, $last_result);
    //update user result for results table
    $all_results[$request->problemID] = $user_result;
    Data::submitModificationQuery(Data::composeUpdateQuery('user', array('results' => serialize($all_results)), 'id=' . Data::quote_smart($user_id)));
    //return submission result
    $res = new AcceptedResponse();
    return $res;
}

function processGetContestDataRequest($request)
{
    $prfx = DB_PREFIX;
    $is_anonymous = is_null($request->sessionID);
    if (!$is_anonymous) {
        //get user_id or die, if session is invalid
        $userRow = RequestUtils::testSession($request->sessionID);
        $user_id = $userRow['id'];
        //authorize user for this operation
        // get contest ID
        $user_type = $userRow['user_type'];
        //compare requested contest and user contest
        $contest_id = RequestUtils::getRequestedContest($request->contestID, $userRow['contest_id'], $user_type);
    } else {
        $contest_id = $request->contestID;
    }
    if ($contest_id <= 0) {
        throwBusinessLogicError(0);
    }
    //create response
    $res = new GetContestDataResponse();
    //fill contest description with data
    //query db
    $row = Data::getRow(sprintf("SELECT * FROM {$prfx}contest WHERE id=%s", Data::quote_smart($contest_id))) or throwBusinessLogicError(14);
    //TODO remove this code duplication, the code is similar to AvailableContests.php
    $c = Data::_unserialize($row['settings']);
    $c->contestID = (int) $row['id'];
    $res->contest = $c;
    //fill problem data
    if ($is_anonymous) {
        return $res;
    }
    //query db to find out problems
    $problems_rows = Data::getRows(sprintf("SELECT * FROM {$prfx}problem WHERE contest_id=%s ORDER BY contest_pos ASC", Data::quote_smart($contest_id)));
    //fill problems data
    $res->problems = array();
    $info_type = $request->infoType;
    $extended_data = $request->extendedData;
    while ($row = Data::getNextRow($problems_rows)) {
        $pd = new ProblemDescription();
        $res->problems[] = $pd;
        $pd->id = (int) $row['id'];
        $pd->settings = Data::_unserialize($row['contest_settings']);
        //do we need any information
        if ($info_type == 'NoInfo') {
            continue;
        }
        //do we need to return some info for this problem
        if (!is_null($extended_data) && !in_array($pd->id, $extended_data)) {
            continue;
        }
        $problem = new Problem(getProblemFile($pd->id));
        if ($info_type !== 'NoInfo') {
            //fill extended data: statement or statementData and answerData
            if ($info_type === "ParticipantInfo") {
                $pd->problem = $problem->getParticipantVersion($user_id)->getProblemBytes();
            } elseif ($info_type === "AdminInfo") {
                if ($user_type === "Participant") {
                    throwBusinessLogicError(0);
                }
                $pd->problem = $problem->getProblemBytes();
            }
        }
    }
    return $res;
}

function processRegisterToContestRequest($request)
{
    $prfx = DB_PREFIX;
    //get user_id or die, if session is invalid
    if (is_null($request->sessionID)) {
        if (!is_numeric($request->contestID)) {
            throwBusinessLogicError(14);
        }
        $contest_id = (int) $request->contestID;
        $request_user_type = '__Anonymous';
    } else {
        $userRow = RequestUtils::testSession($request->sessionID);
        $request_user_id = $userRow['id'];
        $request_user_type = $userRow['user_type'];
        $contest_id = RequestUtils::getRequestedContest($request->contestID, $userRow['contest_id'], $request_user_type);
        //make possible for superadmin to register users of zero-contest
        if ($request_user_type == 'SuperAdmin' && ($request->contestID == 0 || $request->contestID == -1)) {
            $contest_id = 0;
        }
        if ($contest_id == -1) {
            throwBusinessLogicError(0);
        }
    }
    //test permissions
    if ($contest_id != 0) {
        $contest_row = Data::getRow(sprintf("SELECT * FROM {$prfx}contest WHERE id=%s", Data::quote_smart($contest_id))) or throwBusinessLogicError(14);
        //test if this contest gets users only by admins
        $contest_settings = @unserialize($contest_row['settings']);
        if ($contest_settings->registrationType === 'ByAdmins') {
            if ($request_user_type !== "ContestAdmin" && $request_user_type !== "SuperAdmin") {
                throwBusinessLogicError(0);
            }
        }
    } else {
        if ($request_user_type !== "ContestAdmin") {
            throwBusinessLogicError(0);
        }
    }
    //get user from request
    $u = $request->user;
    //test that superadmins are registered only for 0 contest
    if ($u->userType === 'SuperAdmin' && $contest_id != 0) {
        throwBusinessLogicError(18);
    }
    //test that there is no user with the same login in this contest
    if (Data::hasRows(sprintf("SELECT * FROM {$prfx}user WHERE contest_id=%s AND login=%s", Data::quote_smart($contest_id), Data::quote_smart($u->login)))) {
        throwBusinessLogicError(14);
    }
    //not participants may be added only by admins
    if ($u->userType !== "Participant") {
        if ($request_user_type !== "ContestAdmin" && $request_user_type !== "SuperAdmin") {
            throwBusinessLogicError(0);
        }
    }
    //add user finally
    $col_value = array();
    $col_value['login'] = $u->login;
    $col_value['password'] = $u->password;
    $col_value['user_data'] = @serialize($u->dataValue);
    $col_value['contest_id'] = $contest_id;
    $col_value['user_type'] = $u->userType;
    $col_value['results'] = @serialize(array());
    if (strlen($u->login) == 0) {
        throwBusinessLogicError(22);
    }
    if (week_password($u->password)) {
        throwBusinessLogicError(23);
    }
    Data::submitModificationQuery(Data::composeInsertQuery('user', $col_value));
    return new AcceptedResponse();
}

function processGetContestResultsRequest($request)
{
    $prfx = DB_PREFIX;
    //get $is_anonymous, $contest_id, $user_contest_row, $user_contest_start_time
    if (!is_null($request->sessionID)) {
        $is_anonymous = false;
        $user_contest_row = RequestUtils::testSession($request->sessionID);
        $contest_id = RequestUtils::getRequestedContest($request->contestID, $user_contest_row['contest_id'], $user_contest_row['user_type']);
        if ($contest_id < 0) {
            throwBusinessLogicError(14);
        }
        $user_contest_start_time = DateMySQLToPHP($user_contest_row['contest_start']);
        $user_contest_finish_time = DateMySQLToPHP($user_contest_row['contest_finish']);
    } else {
        $is_anonymous = true;
        $contest_id = $request->contestID;
        $user_contest_start_time = null;
        //contest was not started for anonymous
        $user_contest_finish_time = null;
        //and was not finished
    }
    //get $serialized_contest_settings
    $need_request_for_contest_data = $is_anonymous || $user_contest_row['user_type'] === 'SuperAdmin';
    if ($need_request_for_contest_data) {
        if ($contest_id === 0) {
            throwBusinessLogicError(14);
        }
        $contest_row = Data::getRow(sprintf("SELECT *\r\n             FROM {$prfx}contest\r\n             WHERE id=%s\r\n            ", Data::quote_smart($contest_id)));
        if (!$contest_row) {
            throwBusinessLogicError(14);
        }
        $serialized_contest_settings = $contest_row['settings'];
    } else {
        $serialized_contest_settings = $user_contest_row['settings'];
    }
    //get $contest_settings
    $contest_settings = Data::_unserialize($serialized_contest_settings);
    //get $is_admin
    $is_admin = !$is_anonymous && ($user_contest_row['user_type'] === 'SuperAdmin' || $user_contest_row['user_type'] === 'ContestAdmin');
    //get $permission
    $ctime = getCurrentContestTime($contest_settings, $user_contest_start_time, $user_contest_finish_time);
    if (!$is_admin) {
        if ($ctime['interval'] === 'before') {
            throwBusinessLogicError(19);
        }
        if ($ctime['interval'] === 'contest' && !$ctime['is_ending']) {
            $permission = $contest_settings->resultsAccessPolicy->contestPermission;
        } else {
            if ($ctime['is_ending']) {
                $permission = $contest_settings->resultsAccessPolicy->contestEndingPermission;
            } else {
                if ($ctime['interval'] === 'after' && !$ctime['is_ending']) {
                    $permission = $contest_settings->resultsAccessPolicy->afterContestPermission;
                }
            }
        }
    } else {
        $permission = 'FullAccess';
    }
    //test rights
    if ($permission === 'NoAccess') {
        throwBusinessLogicError(0);
    }
    if ($is_anonymous && $permission === "OnlySelfResults") {
        throwBusinessLogicError(0);
    }
    //get problem rows
    $all_problems_rows = Data::getRows(sprintf("SELECT *\r\n                                    FROM {$prfx}problem\r\n                                    WHERE {$prfx}problem.contest_id=%s\r\n                                    ORDER BY {$prfx}problem.contest_pos ASC", Data::quote_smart($contest_id)));
    //get users rows
    if ($permission === 'FullAccess') {
        $all_users_rows = Data::getRows(sprintf("SELECT *\r\n                                     FROM {$prfx}user\r\n                                     WHERE contest_id=%s", Data::quote_smart($contest_id)));
    } else {
        /* if $permission === 'OnlySelfResults'*/
        $all_users_rows = $user_contest_row;
    }
    //create result
    $result = new GetContestResultsResponse();
    //fill columns ids
    $result->headers = array();
    $result->minorHeaders = array();
    //the first column with 'user_id' and 'login'
    if ($is_admin) {
        $result->headers[] = 'admin info';
        $result->minorHeaders[] = array('id', 'login');
    }
    //column with participant data
    $result->headers[] = 'participant';
    //get participant subcolumns
    $data_subs = array();
    $contest_user_data = $contest_settings->data;
    if ($contest_user_data) {
        foreach ($contest_settings->data as $df) {
            if ($is_admin || $df->showInResult) {
                $data_subs[] = $df->data;
            }
        }
    }
    $result->minorHeaders[] = $data_subs;
    //columns with problems
    $problem_ids = array();
//.........这里部分代码省略.........

$a->b->c = "42";
var_dump($a);
var_dump($a->b);
var_dump($a->b->c);
die;
require "utils/DataBase.php";
$dces_mysql_host = "localhost:3306";
$dces_mysql_user = "root";
$dces_mysql_password = "";
$dces_mysql_db = "dcestest";
$dces_mysql_prefix = "pr_";
$dces_logging = true;
$prfx = DB_PREFIX;
//find user in table
//test if there is at least one such user
$row = Data::getRow("SELECT {$prfx}user.*, {$prfx}contest.settings\r\n   FROM {$prfx}session\r\n   INNER JOIN {$prfx}user\r\n   ON {$prfx}session.user_id={$prfx}user.id\r\n   INNER JOIN {$prfx}contest\r\n   ON {$prfx}user.contest_id={$prfx}contest.id\r\n   WHERE session_id='{$session_id}'");
//test if there is at least one user
var_dump($row);
die;
class D
{
    private static $c = 42;
    static function f()
    {
        return D::$c;
    }
}
//var_dump(D::$c);
var_dump(D::f());
$s = false;
if ($s === false) {