/**
* Checks that, if there's no wait time, 0 is posted in max_wait_time
*/
public function testGetStatsNoWaitTime()
{
// Get a problem
$problemData = ProblemsFactory::createProblem();
// Get a contest
$contestData = ContestsFactory::createContest();
// Add the problem to the contest
ContestsFactory::addProblemToContest($problemData, $contestData);
// Create our contestant
$contestant = UserFactory::createUser();
$ACRunsCount = 2;
$ACRunsData = array();
for ($i = 0; $i < $ACRunsCount; $i++) {
$ACRunsData[$i] = RunsFactory::createRun($problemData, $contestData, $contestant);
// Grade the run
RunsFactory::gradeRun($ACRunsData[$i]);
}
// Create request
$r = new Request();
$r['contest_alias'] = $contestData['request']['alias'];
$r['auth_token'] = $this->login($contestData['director']);
// Call API
$response = ContestController::apiStats($r);
// Check number of pending runs
$this->assertEquals($ACRunsCount, $response['total_runs']);
$this->assertEquals(0, $response['max_wait_time']);
$this->assertEquals(0, $response['max_wait_time_guid']);
}
public function testRemoveUser()
{
// Get a contest
$contestData = ContestsFactory::createContest();
// Create a user
$user = UserFactory::createUser();
// Add user to contest
ContestsFactory::addUser($contestData, $user);
// Validate 0 users
$r = new Request();
$r['contest_alias'] = $contestData['request']['alias'];
$r['auth_token'] = $this->login($contestData['director']);
$response = ContestController::apiUsers($r);
$this->assertEquals(1, count($response['users']));
// Remove user
$r = new Request();
$r['contest_alias'] = $contestData['request']['alias'];
$r['usernameOrEmail'] = $user->getUsername();
$r['auth_token'] = $this->login($contestData['director']);
ContestController::apiRemoveUser($r);
// Validate 0 users in contest
$r = new Request();
$r['contest_alias'] = $contestData['request']['alias'];
$r['auth_token'] = $this->login($contestData['director']);
$response = ContestController::apiUsers($r);
$this->assertEquals(0, count($response['users']));
}
/**
* Contestant submits runs and admin is able to get them
*/
public function testGetRunsForContest()
{
// Get a problem
$problemData = ProblemsFactory::createProblem();
// Get a contest
$contestData = ContestsFactory::createContest();
// Add the problem to the contest
ContestsFactory::addProblemToContest($problemData, $contestData);
// Create our contestant
$contestant = UserFactory::createUser();
// Create a run
$runData = RunsFactory::createRun($problemData, $contestData, $contestant);
// Grade the run
RunsFactory::gradeRun($runData);
// Create request
$r = new Request();
$r['contest_alias'] = $contestData['request']['alias'];
$r['auth_token'] = $this->login($contestData['director']);
// Call API
$response = ContestController::apiRuns($r);
// Assert
$this->assertEquals(1, count($response['runs']));
$this->assertEquals($runData['response']['guid'], $response['runs'][0]['guid']);
$this->assertEquals($contestant->username, $response['runs'][0]['username']);
$this->assertEquals('J1', $response['runs'][0]['judged_by']);
}
public function testContestUsersValid()
{
// Get a contest
$contestData = ContestsFactory::createContest();
// Create 10 users
$n = 10;
$users = array();
for ($i = 0; $i < $n; $i++) {
// Create a user
$users[$i] = UserFactory::createUser();
// Add it to the contest
ContestsFactory::addUser($contestData, $users[$i]);
}
// Create a n+1 user who will just join to the contest withot being
// added via API. For public contests, by entering to the contest, the user should be in
// the list of contest's users.
$nonRegisteredUser = UserFactory::createUser();
ContestsFactory::openContest($contestData, $nonRegisteredUser);
// Prepare request
$r = new Request();
$r["contest_alias"] = $contestData["request"]["alias"];
// Log in with the admin of the contest
$r["auth_token"] = $this->login($contestData["director"]);
// Call API
$response = ContestController::apiUsers($r);
// Check that we have n+1 users
$this->assertEquals($n + 1, count($response["users"]));
}
/**
* Contestant submits runs and admin is able to get them
*/
public function testGetRunsForContest()
{
// Get a problem
$problemData = ProblemsFactory::createProblem();
// Get a contest
$contestData = ContestsFactory::createContest();
// Add the problem to the contest
ContestsFactory::addProblemToContest($problemData, $contestData);
// Create our contestant
$contestant = UserFactory::createUser();
// Create a run
$runData = RunsFactory::createRun($problemData, $contestData, $contestant);
// Grade the run
RunsFactory::gradeRun($runData);
// Create request
$r = new Request();
$r["contest_alias"] = $contestData["request"]["alias"];
$r["auth_token"] = $this->login($contestData["director"]);
// Call API
$response = ContestController::apiRuns($r);
// Assert
$this->assertEquals(1, count($response["runs"]));
$this->assertEquals($runData["response"]["guid"], $response["runs"][0]["guid"]);
$this->assertEquals($contestant->username, $response["runs"][0]["username"]);
$this->assertEquals("J1", $response["runs"][0]["judged_by"]);
}
public function testSimpleRegistrationActions()
{
self::log("Started");
//create a contest and its admin
$contestData = ContestsFactory::createContest(null, 1);
$contestAdmin = UserFactory::createUser();
ContestsFactory::addAdminUser($contestData, $contestAdmin);
//make it "registrable"
self::log("Udate contest to make it registrable");
$r1 = new Request();
$r1["contest_alias"] = $contestData["request"]["alias"];
$r1["contestant_must_register"] = true;
$r1["auth_token"] = $this->login($contestAdmin);
ContestController::apiUpdate($r1);
//some user asks for contest
$contestant = UserFactory::createUser();
$r2 = new Request();
$r2["contest_alias"] = $contestData["request"]["alias"];
$r2["auth_token"] = $this->login($contestant);
try {
$response = ContestController::apiDetails($r2);
$this->AssertFalse(true, "User gained access to contest even though its registration needed.");
} catch (ForbiddenAccessException $fae) {
// Expected. Continue.
}
self::log("user registers, into contest");
ContestController::apiRegisterForContest($r2);
//admin lists registrations
$r3 = new Request();
$r3["contest_alias"] = $contestData["request"]["alias"];
$r3["auth_token"] = $this->login($contestAdmin);
$result = ContestController::apiRequests($r3);
$this->assertEquals(sizeof($result["users"]), 1);
self::log("amin rejects registration");
$r3["username"] = $contestant->username;
$r3["resolution"] = false;
ContestController::apiArbitrateRequest($r3);
//ask for details again, this should fail again
$r2 = new Request();
$r2["contest_alias"] = $contestData["request"]["alias"];
$r2["auth_token"] = $this->login($contestant);
try {
$response = ContestController::apiDetails($r2);
$this->AssertFalse(true);
} catch (ForbiddenAccessException $fae) {
// Expected. Continue.
}
//admin admits user
$r3["username"] = $contestant->username;
$r3["resolution"] = true;
ContestController::apiArbitrateRequest($r3);
//user can now submit to contest
$r2 = new Request();
$r2["contest_alias"] = $contestData["request"]["alias"];
$r2["auth_token"] = $this->login($contestant);
// Explicitly join contest
ContestController::apiOpen($r2);
ContestController::apiDetails($r2);
}
/**
*
*/
public function testViewProblemInAContestDetailsValid()
{
// Get a contest
$contestData = ContestsFactory::createContest();
// Get a user to be the author
$author = UserFactory::createUser();
// Get a problem
$problemData = ProblemsFactory::createProblem(null, null, 1, $author);
// Add the problem to the contest
ContestsFactory::addProblemToContest($problemData, $contestData);
// Get a user for our scenario
$contestant = UserFactory::createUser();
// Prepare our request
$r = new Request();
$r["contest_alias"] = $contestData["request"]["alias"];
$r["problem_alias"] = $problemData["request"]["alias"];
// Log in the user
$r["auth_token"] = $this->login($contestant);
// Explicitly join contest
ContestController::apiOpen($r);
// Call api
$response = ProblemController::apiDetails($r);
// Get problem and contest from DB to check it
$problemDAO = ProblemsDAO::getByAlias($problemData["request"]["alias"]);
$contestDAO = ContestsDAO::getByAlias($contestData["request"]["alias"]);
$contestantsDAO = UsersDAO::search(new Users(array("username" => $contestant->getUsername())));
$contestantDAO = $contestantsDAO[0];
// Assert data
$this->assertEquals($response["title"], $problemDAO->getTitle());
$this->assertEquals($response["alias"], $problemDAO->getAlias());
$this->assertEquals($response["validator"], $problemDAO->getValidator());
$this->assertEquals($response["time_limit"], $problemDAO->getTimeLimit());
$this->assertEquals($response["memory_limit"], $problemDAO->getMemoryLimit());
$this->assertEquals($response["problemsetter"]['username'], $author->username);
$this->assertEquals($response["problemsetter"]['name'], $author->name);
$this->assertEquals($response["source"], $problemDAO->getSource());
$this->assertContains("<h1>Entrada</h1>", $response["problem_statement"]);
$this->assertEquals($response["order"], $problemDAO->getOrder());
$this->assertEquals($response["score"], 0);
// Default data
$this->assertEquals(0, $problemDAO->getVisits());
$this->assertEquals(0, $problemDAO->getSubmissions());
$this->assertEquals(0, $problemDAO->getAccepted());
$this->assertEquals(0, $problemDAO->getDifficulty());
// Verify that we have an empty array of runs
$this->assertEquals(0, count($response["runs"]));
// Verify that problem was marked as Opened
$problem_opened = ContestProblemOpenedDAO::getByPK($contestDAO->getContestId(), $problemDAO->getProblemId(), $contestantDAO->getUserId());
$this->assertNotNull($problem_opened);
// Verify open time
$this->assertEquals(Utils::GetPhpUnixTimestamp(), Utils::GetPhpUnixTimestamp($problem_opened->getOpenTime()));
}
/**
* Tests that 2 contests with same name cannot be created
*
* @expectedException DuplicatedEntryInDatabaseException
*/
public function testCreate2ContestsWithSameAlias()
{
// Create a valid contest Request object
$contestData = ContestsFactory::getRequest();
$r = $contestData['request'];
$contestDirector = $contestData['director'];
// Log in the user and set the auth token in the new request
$r['auth_token'] = $this->login($contestDirector);
// Call the API
$response = ContestController::apiCreate($r);
$this->assertEquals('ok', $response['status']);
// Call the API for the 2nd time with same alias
$response = ContestController::apiCreate($r);
}
public function testContestActivityReport()
{
// Get a contest
$contestData = ContestsFactory::createContest();
$user = UserFactory::createUser();
ContestsFactory::openContest($contestData, $user);
ContestController::apiDetails(new Request(array('contest_alias' => $contestData['request']['alias'], 'auth_token' => $this->login($user))));
// Call API
$response = ContestController::apiActivityReport(new Request(array('contest_alias' => $contestData['request']['alias'], 'auth_token' => $this->login($contestData['director']))));
// Check that we have entries in the log.
$this->assertEquals(1, count($response['events']));
$this->assertEquals($user->username, $response['events'][0]['username']);
$this->assertEquals(0, $response['events'][0]['ip']);
$this->assertEquals('open', $response['events'][0]['event']['name']);
}
/**
* Basic test for getting the list of clarifications of a contest.
* Create 4 clarifications in a contest with one user, then another 3 clarifications
* with another user.
* Get the list for the first user, will see only his 4
*/
public function testListPublicClarificationsForContestant()
{
// Get a problem
$problemData = ProblemsFactory::createProblem();
// Get a contest
$contestData = ContestsFactory::createContest();
// Add the problem to the contest
ContestsFactory::addProblemToContest($problemData, $contestData);
// Create our contestant who will submit the clarification
$contestant1 = UserFactory::createUser();
// Create 4 clarifications with this contestant
$clarificationData1 = array();
$this->detourBroadcasterCalls($this->exactly(9));
for ($i = 0; $i < 4; $i++) {
$clarificationData1[$i] = ClarificationsFactory::createClarification($problemData, $contestData, $contestant1);
}
// Answer clarification 0 and 2
ClarificationsFactory::answer($clarificationData1[0], $contestData);
ClarificationsFactory::answer($clarificationData1[2], $contestData);
// Create another contestant
$contestant2 = UserFactory::createUser();
// Create 3 clarifications with this contestant
$clarificationData2 = array();
for ($i = 0; $i < 3; $i++) {
$clarificationData2[$i] = ClarificationsFactory::createClarification($problemData, $contestData, $contestant2);
}
// Prepare the request
$r = new Request();
$r["contest_alias"] = $contestData["request"]["alias"];
// Log in with first user
$r["auth_token"] = $this->login($contestant1);
// Call API
$response = ContestController::apiClarifications($r);
// Check that we got all clarifications
$this->assertEquals(count($clarificationData1), count($response["clarifications"]));
// Check that the clarifications came in the order we expect
// First we expect clarifications not answered
$this->assertEquals($clarificationData1[3]["request"]["message"], $response["clarifications"][0]["message"]);
$this->assertEquals($clarificationData1[1]["request"]["message"], $response["clarifications"][1]["message"]);
// Then clarifications answered, newer first
$this->assertEquals($clarificationData1[2]["request"]["message"], $response["clarifications"][2]["message"]);
$this->assertEquals($clarificationData1[0]["request"]["message"], $response["clarifications"][3]["message"]);
}
/**
* Tests remove admins
*/
public function testRemoveAdmin()
{
// Get a contest
$contestData = ContestsFactory::createContest();
// Get users
$user = UserFactory::createUser();
$user2 = UserFactory::createUser();
ContestsFactory::addAdminUser($contestData, $user);
ContestsFactory::addAdminUser($contestData, $user2);
// Prepare request for remove one admin
$r = new Request();
$r["auth_token"] = $this->login($contestData["director"]);
$r["usernameOrEmail"] = $user->getUsername();
$r["contest_alias"] = $contestData["request"]["alias"];
// Call api
ContestController::apiRemoveAdmin($r);
$contest = ContestsDAO::getByAlias($contestData['request']['alias']);
$this->AssertFalse(Authorization::IsContestAdmin($user->getUserId(), $contest));
$this->AssertTrue(Authorization::IsContestAdmin($user2->getUserId(), $contest));
}
<?php
require_once '../../server/bootstrap.php';
$smarty->assign('admin', false);
$smarty->assign('practice', false);
$r = new Request(array("auth_token" => array_key_exists("ouat", $_REQUEST) ? $_REQUEST["ouat"] : null, "contest_alias" => $_REQUEST["contest_alias"]));
if (ContestController::showContestIntro($r)) {
$smarty->display('../../templates/arena.contest.intro.tpl');
} else {
$smarty->assign('jsfile', '/ux/contest.js');
$smarty->display('../../templates/arena.contest.tpl');
}
/**
* Tests contest report used in OMI
*/
public function testContestReport()
{
// Get a contest
$contestData = ContestsFactory::createContest();
$contestDirector = $contestData["director"];
// Get a problem
$problemData = ProblemsFactory::createProblemWithAuthor($contestDirector);
// Add the problem to the contest
ContestsFactory::addProblemToContest($problemData, $contestData);
// Create our contestants
$contestants = array();
array_push($contestants, UserFactory::createUser());
array_push($contestants, UserFactory::createUser());
array_push($contestants, UserFactory::createUser());
$contestAdmin = UserFactory::createUser();
ContestsFactory::addAdminUser($contestData, $contestAdmin);
// Create runs
$runsData = array();
$runsData[0] = RunsFactory::createRun($problemData, $contestData, $contestants[0]);
$runsData[1] = RunsFactory::createRun($problemData, $contestData, $contestants[0]);
$runsData[2] = RunsFactory::createRun($problemData, $contestData, $contestants[1]);
$runsData[3] = RunsFactory::createRun($problemData, $contestData, $contestants[2]);
$runDataDirector = RunsFactory::createRun($problemData, $contestData, $contestDirector);
$runDataAdmin = RunsFactory::createRun($problemData, $contestData, $contestAdmin);
// Grade the runs
RunsFactory::gradeRun($runsData[0], 0, "CE");
RunsFactory::gradeRun($runsData[1]);
RunsFactory::gradeRun($runsData[2], 0.9, "PA");
RunsFactory::gradeRun($runsData[3], 1, "AC", 180);
RunsFactory::gradeRun($runDataDirector, 1, "AC", 120);
RunsFactory::gradeRun($runDataAdmin, 1, "AC", 110);
// Create API
$response = ContestController::apiReport(new Request(array("contest_alias" => $contestData["request"]["alias"], "auth_token" => $this->login($contestDirector))));
$this->assertEquals($problemData["request"]["alias"], $response["problems"][0]["alias"]);
foreach ($contestants as $contestant) {
$found = false;
foreach ($response["ranking"] as $rank) {
if ($rank["username"] == $contestant->username) {
$found = true;
break;
}
}
$this->assertTrue($found);
}
}
public static function addAdminUser($contestData, $user)
{
// Prepare our request
$r = new Request();
$r["contest_alias"] = $contestData["request"]["alias"];
$r["usernameOrEmail"] = $user->getUsername();
// Log in the contest director
$r["auth_token"] = OmegaupTestCase::login($contestData["director"]);
// Call api
ContestController::apiAddAdmin($r);
unset($_REQUEST);
}
/**
*
*/
public function testPrivateContestForContestAdmin()
{
$r = new Request();
// Create new private contest
$contestData = ContestsFactory::createContest(null, false);
// Get a user for our scenario
$contestant = UserFactory::createUser();
// Add user to our private contest
ContestsFactory::addAdminUser($contestData, $contestant);
$r["auth_token"] = $this->login($contestant);
$response = ContestController::apiList($r);
// Assert our contest is there
$this->assertTitleInList($response, $contestData);
}
/**
* Generates a CSV for contest report
*
* @param Request $r
* @return array
*/
public static function apiCsvReport(Request $r)
{
self::authenticateRequest($r);
self::validateStats($r);
// Get full Report API of the contest
$reportRequest = new Request(array("contest_alias" => $r["contest_alias"], "auth_token" => $r["auth_token"]));
$contestReport = self::apiReport($reportRequest);
// Get problem stats for each contest problem so we can
// have the full list of cases
$problemStats = array();
$i = 0;
foreach ($contestReport["problems"] as $entry) {
$problem_alias = $entry["alias"];
$problemStatsRequest = new Request(array("problem_alias" => $problem_alias, "auth_token" => $r["auth_token"]));
$problemStats[$i] = ProblemController::apiStats($problemStatsRequest);
$problemStats[$problem_alias] = $problemStats[$i];
$i++;
}
// Build a csv
$csvData = array();
// Build titles
$csvRow = array();
$csvRow[] = "username";
foreach ($contestReport["problems"] as $entry) {
foreach ($problemStats[$entry["alias"]]["cases_stats"] as $caseName => $counts) {
$csvRow[] = $caseName;
}
$csvRow[] = $entry["alias"] . " total";
}
$csvRow[] = "total";
$csvData[] = $csvRow;
foreach ($contestReport["ranking"] as $userData) {
if ($userData === "ok") {
continue;
}
$csvRow = array();
$csvRow[] = $userData["username"];
foreach ($userData["problems"] as $key => $problemData) {
// If the user don't have these details then he didn't submit,
// we need to fill the report with 0s for completeness
if (!isset($problemData["run_details"]["cases"]) || count($problemData["run_details"]["cases"]) === 0) {
for ($i = 0; $i < count($problemStats[$key]["cases_stats"]); $i++) {
$csvRow[] = '0';
}
// And adding the total for this problem
$csvRow[] = '0';
} else {
// for each case
foreach ($problemData["run_details"]["cases"] as $caseData) {
// If case is correct
if (strcmp($caseData["meta"]["status"], "OK") === 0 && strcmp($caseData["out_diff"], "") === 0) {
$csvRow[] = '1';
} else {
$csvRow[] = '0';
}
}
$csvRow[] = $problemData["points"];
}
}
$csvRow[] = $userData["total"]["points"];
$csvData[] = $csvRow;
}
// Set headers to auto-download file
header("Pragma: public");
header("Expires: 0");
header("Cache-Control: must-revalidate, post-check=0, pre-check=0");
header("Content-Type: application/force-download");
header("Content-Type: application/octet-stream");
header("Content-Type: application/download");
header("Content-Disposition: attachment;filename=" . $r["contest_alias"] . "_report.csv");
header("Content-Transfer-Encoding: binary");
// Write contents to a csv raw string
// TODO(https://github.com/omegaup/omegaup/issues/628): Escape = to prevent applications from inadvertently executing code
// http://contextis.co.uk/blog/comma-separated-vulnerabilities/
$out = fopen('php://output', 'w');
foreach ($csvData as $csvRow) {
fputcsv($out, ContestController::escapeCsv($csvRow));
}
fclose($out);
// X_X
die;
}
/**
* Update from private to public with problems added
*
*/
public function testUpdatePrivateContestToPublicWithProblems()
{
// Get a contest
$contestData = ContestsFactory::createContest(null, 0);
// Get a problem
$problemData = ProblemsFactory::createProblem();
// Add the problem to the contest
ContestsFactory::addProblemToContest($problemData, $contestData);
// Prepare request
$r = new Request();
$r["contest_alias"] = $contestData["request"]["alias"];
// Log in with contest director
$r["auth_token"] = $this->login($contestData["director"]);
// Update public
$r["public"] = 1;
// Call API
$response = ContestController::apiUpdate($r);
$contestData["request"]["public"] = $r["public"];
$this->assertContest($contestData["request"]);
}
/**
* Set Recommended flag to a given contest from non admin account
*
* @expectedException ForbiddenAccessException
*/
public function testSetRecommendedFlagNonAdmin()
{
// Get a contest
$contestData = ContestsFactory::createContest();
// Prepare request
$r = new Request();
$r['contest_alias'] = $contestData['request']['alias'];
// Log in with contest owner
$r['auth_token'] = $this->login($contestData['director']);
// Update value to TRUE
$r['value'] = 1;
// Call API
ContestController::apiSetRecommended($r);
}
/**
* Test that contests with recommended flag show first in list.
*/
public function testRecommendedShowsOnTop()
{
$r = new Request();
// Create 2 contests, with the not-recommended.finish_time > recommended.finish_time
$recommendedContestData = ContestsFactory::createContest();
$notRecommendedContestData = ContestsFactory::createContest(null, 0, null, $recommendedContestData['request']['finish_time'] + 1);
// Get a user for our scenario
$contestant = UserFactory::createUser();
// Turn recommended ON
$r = new Request();
$r['contest_alias'] = $recommendedContestData['request']['alias'];
$r['auth_token'] = $this->login(UserFactory::createAdminUser());
$r['value'] = 1;
ContestController::apiSetRecommended($r);
// Get list of contests
$r['auth_token'] = $this->login($contestant);
$response = ContestController::apiList($r);
// Check that recommended contest is earlier in list han not-recommended
$recommendedPosition = 0;
$notRecommendedPosition = 0;
foreach ($response['results'] as $contest) {
if ($contest['title'] == $recommendedContestData['request']['title']) {
break;
}
$recommendedPosition++;
}
foreach ($response['results'] as $contest) {
if ($contest['title'] == $notRecommendedContestData['request']['title']) {
break;
}
$notRecommendedPosition++;
}
$this->assertTrue($recommendedPosition < $notRecommendedPosition);
}
/**
* Details of a scoreboard. Returns a list with all contests that belong to
* the given scoreboard_alias
*
* @param Request $r
*/
public static function apiDetails(Request $r)
{
self::validateGroupScoreboard($r);
$response = array();
// Fill contests
$response['contests'] = array();
$response['ranking'] = array();
try {
$groupScoreboardContestKey = new GroupsScoreboardsContests(array('group_scoreboard_id' => $r['scoreboard']->group_scoreboard_id));
$r['gscs'] = GroupsScoreboardsContestsDAO::search($groupScoreboardContestKey);
$i = 0;
$contest_params = array();
foreach ($r['gscs'] as $gsc) {
$contest = ContestsDAO::getByPK($gsc->contest_id);
$response['contests'][$i] = $contest->asArray();
$response['contests'][$i]['only_ac'] = $gsc->only_ac;
$response['contests'][$i]['weight'] = $gsc->weight;
// Fill contest params to pass to scoreboardMerge
$contest_params[$contest->alias] = array('only_ac' => $gsc->only_ac == 0 ? false : true, 'weight' => $gsc->weight);
$i++;
}
} catch (ApiException $ex) {
throw $ex;
} catch (Exception $ex) {
throw new InvalidDatabaseOperationException($ex);
}
$r['contest_params'] = $contest_params;
// Fill details of this scoreboard
$response['scoreboard'] = $r['scoreboard']->asArray();
// If we have contests, calculate merged&filtered scoreboard
if (count($response['contests']) > 0) {
// Get merged scoreboard
$r['contest_aliases'] = '';
foreach ($response['contests'] as $contest) {
$r['contest_aliases'] .= $contest['alias'] . ',';
}
$r['contest_aliases'] = rtrim($r['contest_aliases'], ',');
try {
$groupUsers = GroupsUsersDAO::search(new GroupsUsers(array('group_id' => $r['scoreboard']->group_id)));
$r['usernames_filter'] = '';
foreach ($groupUsers as $groupUser) {
$user = UsersDAO::getByPK($groupUser->user_id);
$r['usernames_filter'] .= $user->username . ',';
}
$r['usernames_filter'] = rtrim($r['usernames_filter'], ',');
} catch (Exception $ex) {
throw new InvalidDatabaseOperationException($ex);
}
$mergedScoreboardResponse = ContestController::apiScoreboardMerge($r);
$response['ranking'] = $mergedScoreboardResponse['ranking'];
}
$response['status'] = 'ok';
return $response;
}
/**
* Check that user in private list can view private contest
*/
public function testNoPrivilegeEscalationOccurs()
{
// Get a contest
$contestData = ContestsFactory::createContest(null, 0);
// Get some problems into the contest
$numOfProblems = 3;
$problems = $this->insertProblemsInContest($contestData, $numOfProblems);
// Get a user for our scenario
$contestant = UserFactory::createUser();
// Prepare our request
$r = new Request(array('auth_token' => $this->login($contestant), 'contest_alias' => $contestData['request']['alias']));
// Call api. This should fail.
try {
ContestController::apiDetails($r);
$this->assertTrue(false, 'User with no access could see the contest');
} catch (ForbiddenAccessException $e) {
// Pass
}
// Get details from a problem in that contest. This should also fail.
try {
$problem_request = new Request(array('auth_token' => $this->login($contestant), 'contest_alias' => $contestData['request']['alias'], 'problem_alias' => $problems[0]['request']['alias']));
ProblemController::apiDetails($problem_request);
$this->assertTrue(false, 'User with no access could see the problem');
} catch (ForbiddenAccessException $e) {
// Pass
}
// Call api again. This should (still) fail.
try {
$response = ContestController::apiDetails($r);
$this->assertTrue(false, 'User with no access could see the contest');
} catch (ForbiddenAccessException $e) {
// Pass
}
}
/**
* Basic tests for shareable scoreboard url
*/
public function testScoreboardUrlNoLogin()
{
// Get a private contest with 0% of scoreboard show percentage
$contestData = ContestsFactory::createContest(null, 0);
ContestsFactory::setScoreboardPercentage($contestData, 0);
// Create problem
$problemData = ProblemsFactory::createProblem();
ContestsFactory::addProblemToContest($problemData, $contestData);
// Create our contestant, will submit 1 run
$contestant = UserFactory::createUser();
ContestsFactory::addUser($contestData, $contestant);
$runData = RunsFactory::createRun($problemData, $contestData, $contestant);
RunsFactory::gradeRun($runData);
// Get the scoreboard url by using the MyList api being the
// contest director
$response = ContestController::apiMyList(new Request(array('auth_token' => $this->login($contestData['director']))));
// Look for our contest from the list and save the scoreboard tokens
$scoreboard_url = null;
$scoreboard_admin_url = null;
foreach ($response['results'] as $c) {
if ($c['alias'] === $contestData['request']['alias']) {
$scoreboard_url = $c['scoreboard_url'];
$scoreboard_admin_url = $c['scoreboard_url_admin'];
break;
}
}
$this->assertNotNull($scoreboard_url);
$this->assertNotNull($scoreboard_admin_url);
// Call scoreboard api from the user
$scoreboardResponse = ContestController::apiScoreboard(new Request(array('contest_alias' => $contestData['request']['alias'], 'token' => $scoreboard_url)));
$this->assertEquals('0', $scoreboardResponse['ranking'][0]['total']['points']);
// Call scoreboard api from the user with admin token
$scoreboardResponse = ContestController::apiScoreboard(new Request(array('contest_alias' => $contestData['request']['alias'], 'token' => $scoreboard_admin_url)));
$this->assertEquals('100', $scoreboardResponse['ranking'][0]['total']['points']);
}
/**
* Get Contests which a certain user has participated in
*
* @param Request $r
* @return Contests array
* @throws InvalidDatabaseOperationException
*/
public static function apiContestStats(Request $r)
{
self::authenticateOrAllowUnauthenticatedRequest($r);
$response = array();
$response['contests'] = array();
$user = self::resolveTargetUser($r);
// Get contests where user had at least 1 run
try {
$contestsParticipated = ContestsDAO::getContestsParticipated($user->getUserId());
} catch (Exception $e) {
throw new InvalidDatabaseOperationException($e);
}
$contests = array();
foreach ($contestsParticipated as $contest) {
// Get user ranking
$scoreboardR = new Request(array('auth_token' => $r['auth_token'], 'contest_alias' => $contest->getAlias(), 'token' => $contest->getScoreboardUrlAdmin()));
$scoreboardResponse = ContestController::apiScoreboard($scoreboardR);
// Grab the place of the current user in the given contest
$contests[$contest->getAlias()]['place'] = null;
foreach ($scoreboardResponse['ranking'] as $userData) {
if ($userData['username'] == $user->getUsername()) {
$contests[$contest->getAlias()]['place'] = $userData['place'];
break;
}
}
$contest->toUnixTime();
$contests[$contest->getAlias()]['data'] = $contest->asArray();
}
$response['contests'] = $contests;
$response['status'] = 'ok';
return $response;
}
/**
* Details of a scoreboard. Returns a list with all contests that belong to
* the given scoreboard_alias
*
* @param Request $r
*/
public static function apiDetails(Request $r)
{
self::validateGroupScoreboard($r);
$response = array();
// Fill contests
$response["contests"] = array();
$response["ranking"] = array();
try {
$groupScoreboardContestKey = new GroupsScoreboardsContests(array("group_scoreboard_id" => $r["scoreboard"]->group_scoreboard_id));
$r["gscs"] = GroupsScoreboardsContestsDAO::search($groupScoreboardContestKey);
$i = 0;
$contest_params = array();
foreach ($r["gscs"] as $gsc) {
$contest = ContestsDAO::getByPK($gsc->contest_id);
$response["contests"][$i] = $contest->asArray();
$response["contests"][$i]["only_ac"] = $gsc->only_ac;
$response["contests"][$i]["weight"] = $gsc->weight;
// Fill contest params to pass to scoreboardMerge
$contest_params[$contest->alias] = array("only_ac" => $gsc->only_ac == 0 ? false : true, "weight" => $gsc->weight);
$i++;
}
} catch (ApiException $ex) {
throw $ex;
} catch (Exception $ex) {
throw new InvalidDatabaseOperationException($ex);
}
$r["contest_params"] = $contest_params;
// Fill details of this scoreboard
$response["scoreboard"] = $r["scoreboard"]->asArray();
// If we have contests, calculate merged&filtered scoreboard
if (count($response["contests"]) > 0) {
// Get merged scoreboard
$r["contest_aliases"] = "";
foreach ($response["contests"] as $contest) {
$r["contest_aliases"] .= $contest["alias"] . ",";
}
$r["contest_aliases"] = rtrim($r["contest_aliases"], ",");
try {
$groupUsers = GroupsUsersDAO::search(new GroupsUsers(array("group_id" => $r["scoreboard"]->group_id)));
$r["usernames_filter"] = "";
foreach ($groupUsers as $groupUser) {
$user = UsersDAO::getByPK($groupUser->user_id);
$r["usernames_filter"] .= $user->username . ",";
}
$r["usernames_filter"] = rtrim($r["usernames_filter"], ",");
} catch (Exception $ex) {
throw new InvalidDatabaseOperationException($ex);
}
$mergedScoreboardResponse = ContestController::apiScoreboardMerge($r);
$response["ranking"] = $mergedScoreboardResponse["ranking"];
}
$response["status"] = "ok";
return $response;
}
<?php
require_once '../../server/bootstrap.php';
$smarty->assign('admin', false);
$smarty->assign('practice', false);
$show_intro = true;
try {
$r = new Request(array('auth_token' => array_key_exists('ouat', $_REQUEST) ? $_REQUEST['ouat'] : null, 'contest_alias' => $_REQUEST['contest_alias']));
$show_intro = ContestController::showContestIntro($r);
} catch (Exception $e) {
header('HTTP/1.1 404 Not Found');
die(file_get_contents('../404.html'));
}
if ($show_intro) {
$smarty->display('../../templates/arena.contest.intro.tpl');
} else {
$smarty->assign('jsfile', '/ux/contest.js');
$smarty->display('../../templates/arena.contest.tpl');
}
/**
* Add too many problems to a contest.
*/
public function testAddTooManyProblemsToContest()
{
// Get a contest
$contestData = ContestsFactory::createContest();
$auth_token = $this->login($contestData["director"]);
for ($i = 0; $i < MAX_PROBLEMS_IN_CONTEST + 1; $i++) {
// Get a problem
$problemData = ProblemsFactory::createProblemWithAuthor($contestData['director']);
// Build request
$r = new Request(array("auth_token" => $auth_token, "contest_alias" => $contestData["contest"]->alias, "problem_alias" => $problemData["request"]["alias"], "points" => 100, "order_in_contest" => $i + 1));
try {
// Call API
$response = ContestController::apiAddProblem($r);
$this->assertLessThan(MAX_PROBLEMS_IN_CONTEST, $i);
// Validate
$this->assertEquals("ok", $response["status"]);
self::assertProblemAddedToContest($problemData, $contestData, $r);
} catch (ApiException $e) {
$this->assertEquals($e->getMessage(), "contestAddproblemTooManyProblems");
$this->assertEquals($i, MAX_PROBLEMS_IN_CONTEST);
}
}
}
/**
* Tests remove group admins
*/
public function testRemoveGroupAdmin()
{
// Get a contest
$contestData = ContestsFactory::createContest();
// Get users
$user = UserFactory::createUser();
$user2 = UserFactory::createUser();
// Get a group
$groupData = GroupsFactory::createGroup();
GroupsFactory::addUserToGroup($groupData, $user);
GroupsFactory::addUserToGroup($groupData, $user2);
// Prepare request
$r = new Request();
$r['auth_token'] = $this->login($contestData['director']);
$r['group'] = $groupData['request']['alias'];
$r['contest_alias'] = $contestData['request']['alias'];
// Call api
ContestController::apiAddGroupAdmin($r);
$contest = $contestData['contest'];
$this->AssertTrue(Authorization::IsContestAdmin($user->getUserId(), $contest));
$this->AssertTrue(Authorization::IsContestAdmin($user2->getUserId(), $contest));
// Prepare request for remove the group
$r = new Request();
$r['auth_token'] = $this->login($contestData['director']);
$r['group'] = $groupData['request']['alias'];
$r['contest_alias'] = $contestData['request']['alias'];
// Call api
ContestController::apiRemoveGroupAdmin($r);
$this->AssertFalse(Authorization::IsContestAdmin($user->getUserId(), $contest));
$this->AssertFalse(Authorization::IsContestAdmin($user2->getUserId(), $contest));
}
public static function addAdminUser($contestData, $user)
{
// Prepare our request
$r = new Request();
$r['contest_alias'] = $contestData['request']['alias'];
$r['usernameOrEmail'] = $user->getUsername();
// Log in the contest director
$r['auth_token'] = OmegaupTestCase::login($contestData['director']);
// Call api
ContestController::apiAddAdmin($r);
unset($_REQUEST);
}
/**
* Get Contests which a certain user has participated in
*
* @param Request $r
* @return Contests array
* @throws InvalidDatabaseOperationException
*/
public static function apiContestStats(Request $r)
{
self::authenticateOrAllowUnauthenticatedRequest($r);
$response = array();
$response["contests"] = array();
$user = self::resolveTargetUser($r);
$contest_user_key = new ContestsUsers();
$contest_user_key->setUserId($user->getUserId());
// Get contests where user had at least 1 run
try {
$contestsParticipated = ContestsDAO::getContestsParticipated($user->getUserId());
} catch (Exception $e) {
throw new InvalidDatabaseOperationException($e);
}
$contests = array();
foreach ($contestsParticipated as $contest) {
// Get user ranking
$scoreboardR = new Request(array("auth_token" => $r["auth_token"], "contest_alias" => $contest->getAlias(), "token" => $contest->getScoreboardUrlAdmin()));
$scoreboardResponse = ContestController::apiScoreboard($scoreboardR);
// Grab the place of the current user in the given contest
$contests[$contest->getAlias()]["place"] = null;
foreach ($scoreboardResponse["ranking"] as $userData) {
if ($userData["username"] == $user->getUsername()) {
$contests[$contest->getAlias()]["place"] = $userData["place"];
break;
}
}
$contest->toUnixTime();
$contests[$contest->getAlias()]["data"] = $contest->asArray();
}
$response["contests"] = $contests;
$response["status"] = "ok";
return $response;
}
