protected function sendClarificationEmail(Request $r, $time) { if (!OMEGAUP_EMAIL_SEND_EMAILS || !is_null($r['clarification']->answer) || !$r['problem']->email_clarifications) { return; } try { $emails = ProblemsDAO::getExplicitAdminEmails($r['problem']); $mail = new PHPMailer(); $mail->IsSMTP(); $mail->Host = OMEGAUP_EMAIL_SMTP_HOST; $mail->SMTPAuth = true; $mail->Password = OMEGAUP_EMAIL_SMTP_PASSWORD; $mail->From = OMEGAUP_EMAIL_SMTP_FROM; $mail->Port = 465; $mail->SMTPSecure = 'ssl'; $mail->Username = OMEGAUP_EMAIL_SMTP_FROM; $mail->FromName = OMEGAUP_EMAIL_SMTP_FROM; foreach ($emails as $email) { $mail->AddAddress($email); } $mail->isHTML(true); global $smarty; $email_params = array('clarification_id' => $r['clarification']->clarification_id, 'clarification_body' => htmlspecialchars($r['clarification']->message), 'problem_alias' => $r['problem']->alias, 'problem_name' => htmlspecialchars($r['problem']->title), 'url' => is_null($r['contest']) ? 'https://omegaup.com/arena/problem/' . $r['problem']->alias . '#clarifications' : 'https://omegaup.com/arena/' . $r['contest']->alias . '#clarifications', 'user_name' => $r['user']->username); $mail->Subject = ApiUtils::FormatString($smarty->getConfigVars('clarificationEmailSubject'), $email_params); $mail->Body = ApiUtils::FormatString($smarty->getConfigVars('clarificationEmailBody'), $email_params); if (!$mail->Send()) { $this->log->error('Failed to send mail: ' . $mail->ErrorInfo); } } catch (Exception $e) { $this->log->error('Failed to send clarification email ' . $e->getMessage()); } }
public function testEditProblem() { // Login $author = $this->createUserAndLogin(); // Create a problem $problemData = ProblemsFactory::createProblem(null, null, 1, $author); // Open problem create $this->open('/problemedit.php'); sleep(1); $this->type('name=edit-problem-list', $problemData["request"]["alias"]); $this->waitForValue('name=title', $problemData["request"]["title"]); $problemNewData = ProblemsFactory::getRequest(); $this->type('name=title', $problemNewData["request"]["title"]); $this->type('source', $problemNewData["request"]["source"]); $this->type('time_limit', '666'); $this->type('memory_limit', '1234'); $this->type('validator', 'token-caseless'); $this->type('public', '1'); // Click inicia sesion $this->clickAndWait("//input[@value='Actualizar problema']"); $this->assertElementContainsText('//*[@id="content"]/div[2]/div', "Problem updated succesfully!"); // Verify data in DB $problem_mask = new Problems(); $problem_mask->setTitle($problemNewData["request"]["title"]); $problems = ProblemsDAO::search($problem_mask); // Check that we only retreived 1 element $this->assertEquals(1, count($problems)); $this->assertEquals($problemNewData["request"]["source"], $problems[0]->getSource()); $this->assertEquals(666, $problems[0]->getTimeLimit()); $this->assertEquals(1234, $problems[0]->getMemoryLimit()); $this->assertEquals('token-caseless', $problems[0]->getValidator()); $this->assertEquals('1', $problems[0]->getPublic()); }
/** * Creates a valid clarification */ public function testCreateValidClarification() { // 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 $contestant = UserFactory::createUser(); // Call the API $this->detourBroadcasterCalls(); $clarificationData = ClarificationsFactory::createClarification($problemData, $contestData, $contestant); // Assert status of new contest $this->assertArrayHasKey("clarification_id", $clarificationData['response']); // Verify that clarification was inserted in the database $clarification = ClarificationsDAO::getByPK($clarificationData['response']['clarification_id']); // Verify our retreived clarificatoin $this->assertNotNull($clarification); $this->assertEquals($clarificationData['request']['message'], $clarification->getMessage()); // We need to verify that the contest and problem IDs where properly saved // Extractiing the contest and problem from DB to check IDs $problem = ProblemsDAO::getByAlias($problemData["request"]["alias"]); $contest = ContestsDAO::getByAlias($contestData["request"]["alias"]); $this->assertEquals($contest->getContestId(), $clarification->getContestId()); $this->assertEquals($problem->getProblemId(), $clarification->getProblemId()); }
/** * Check in DB for problem added to contest * * @param array $problemData * @param array $contestData * @param Request $r */ public static function assertProblemAddedToContest($problemData, $contestData, $r) { // Get problem and contest from DB $problem = ProblemsDAO::getByAlias($problemData["request"]["alias"]); $contest = ContestsDAO::getByAlias($contestData["request"]["alias"]); // Get problem-contest and verify it $contest_problems = ContestProblemsDAO::getByPK($contest->getContestId(), $problem->getProblemId()); self::assertNotNull($contest_problems); self::assertEquals($r["points"], $contest_problems->getPoints()); self::assertEquals($r["order_in_contest"], $contest_problems->getOrder()); }
/** * */ 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())); }
public static function CanEditClarification($user_id, Clarifications $clarification) { if (is_null($clarification) || !is_a($clarification, 'Clarifications')) { return false; } try { $contest = ContestsDAO::getByPK($clarification->getContestId()); $problem = ProblemsDAO::getByPK($clarification->getProblemId()); } catch (Exception $e) { throw new InvalidDatabaseOperationException($e); } if (is_null($contest) || is_null($problem)) { return false; } return $problem->getAuthorId() === $user_id || Authorization::IsContestAdmin($user_id, $contest); }
/** * Checks the contest details response * * @param type $contestData * @param type $problems * @param type $response */ private function assertContestDetails($contestData, $problems, $response) { // To validate, grab the contest object directly from the DB $contest = ContestsDAO::getByAlias($contestData['request']['alias']); // Assert we are getting correct data $this->assertEquals($contest->getDescription(), $response['description']); $this->assertEquals(Utils::GetPhpUnixTimestamp($contest->getStartTime()), $response['start_time']); $this->assertEquals(Utils::GetPhpUnixTimestamp($contest->getFinishTime()), $response['finish_time']); $this->assertEquals($contest->getWindowLength(), $response['window_length']); $this->assertEquals($contest->getAlias(), $response['alias']); $this->assertEquals($contest->getPointsDecayFactor(), $response['points_decay_factor']); $this->assertEquals($contest->getPartialScore(), $response['partial_score']); $this->assertEquals($contest->getSubmissionsGap(), $response['submissions_gap']); $this->assertEquals($contest->getFeedback(), $response['feedback']); $this->assertEquals($contest->getPenalty(), $response['penalty']); $this->assertEquals($contest->getScoreboard(), $response['scoreboard']); $this->assertEquals($contest->penalty_type, $response['penalty_type']); $this->assertEquals($contest->getPenaltyCalcPolicy(), $response['penalty_calc_policy']); // Assert we have our problems $numOfProblems = count($problems); $this->assertEquals($numOfProblems, count($response['problems'])); // Assert problem data $i = 0; foreach ($response['problems'] as $problem_array) { // Get problem from DB $problem = ProblemsDAO::getByAlias($problems[$i]['request']['alias']); // Assert data in DB $this->assertEquals($problem->getTitle(), $problem_array['title']); $this->assertEquals($problem->getAlias(), $problem_array['alias']); $this->assertEquals($problem->getValidator(), $problem_array['validator']); $this->assertEquals($problem->getTimeLimit(), $problem_array['time_limit']); $this->assertEquals($problem->getMemoryLimit(), $problem_array['memory_limit']); $this->assertEquals($problem->getVisits(), $problem_array['visits']); $this->assertEquals($problem->getSubmissions(), $problem_array['submissions']); $this->assertEquals($problem->getAccepted(), $problem_array['accepted']); $this->assertEquals($problem->getOrder(), $problem_array['order']); // Get points of problem from Contest-Problem relationship $problemInContest = ContestProblemsDAO::getByPK($contest->getContestId(), $problem->getProblemId()); $this->assertEquals($problemInContest->getPoints(), $problem_array['points']); $i++; } }
public static function getCurrentSession(Request $r) { $authToken = $r['auth_token']; if (is_null($authToken)) { return array('valid' => false, 'id' => null, 'name' => null, 'username' => null, 'email' => null, 'email_md5' => null, 'auth_token' => null, 'is_admin' => false, 'login_url' => '/login/'); } $vo_CurrentUser = AuthTokensDAO::getUserByToken($authToken); if (is_null($vo_CurrentUser)) { // Means user has auth token, but at // does not exist in DB return array('valid' => false, 'id' => null, 'name' => null, 'username' => null, 'email' => null, 'email_md5' => null, 'auth_token' => null, 'is_admin' => false, 'login_url' => '/login/'); } // Get email via his id $vo_Email = EmailsDAO::getByPK($vo_CurrentUser->getMainEmailId()); $_SESSION['omegaup_user'] = array('name' => $vo_CurrentUser->getUsername(), 'email' => !is_null($vo_Email) ? $vo_Email->getEmail() : ''); return array('valid' => true, 'id' => $vo_CurrentUser->getUserId(), 'name' => $vo_CurrentUser->getName(), 'email' => !is_null($vo_Email) ? $vo_Email->getEmail() : '', 'email_md5' => !is_null($vo_Email) ? md5($vo_Email->getEmail()) : '', 'user' => $vo_CurrentUser, 'username' => $vo_CurrentUser->getUsername(), 'auth_token' => $authToken, 'is_email_verified' => $vo_CurrentUser->getVerified(), 'is_admin' => Authorization::IsSystemAdmin($vo_CurrentUser->getUserId()), 'private_contests_count' => ContestsDAO::getPrivateContestsCount($vo_CurrentUser), 'private_problems_count' => ProblemsDAO::getPrivateCount($vo_CurrentUser), 'needs_basic_info' => $vo_CurrentUser->getPassword() == null); }
/** * Validator for List API * * @param Request $r * @throws ForbiddenAccessException * @throws InvalidDatabaseOperationException * @throws NotFoundException */ private static function validateList(Request $r) { // Defaults for offset and rowcount if (!isset($r["offset"])) { $r["offset"] = 0; } if (!isset($r["rowcount"])) { $r["rowcount"] = 100; } if (!Authorization::IsSystemAdmin($r["current_user_id"])) { throw new ForbiddenAccessException("userNotAllowed"); } Validators::isNumber($r["offset"], "offset", false); Validators::isNumber($r["rowcount"], "rowcount", false); Validators::isInEnum($r["status"], "status", array('new', 'waiting', 'compiling', 'running', 'ready'), false); Validators::isInEnum($r["verdict"], "verdict", array("AC", "PA", "WA", "TLE", "MLE", "OLE", "RTE", "RFE", "CE", "JE", "NO-AC"), false); // Check filter by problem, is optional if (!is_null($r["problem_alias"])) { Validators::isStringNonEmpty($r["problem_alias"], "problem"); try { $r["problem"] = ProblemsDAO::getByAlias($r["problem_alias"]); } catch (Exception $e) { // Operation failed in the data layer throw new InvalidDatabaseOperationException($e); } if (is_null($r["problem"])) { throw new NotFoundException("problemNotFound"); } } Validators::isInEnum($r["language"], "language", array('c', 'cpp', 'cpp11', 'java', 'py', 'rb', 'pl', 'cs', 'pas', 'kp', 'kj', 'cat', 'hs'), false); // Get user if we have something in username if (!is_null($r["username"])) { try { $r["user"] = UserController::resolveUser($r["username"]); } catch (NotFoundException $e) { // If not found, simply ignore it $r["username"] = null; $r["user"] = null; } } }
<?php require_once '../../server/bootstrap.php'; $r = new Request($_REQUEST); $session = SessionController::apiCurrentSession($r); $r['statement_type'] = 'html'; $r['show_solvers'] = true; try { $result = ProblemController::apiDetails($r); $problem = ProblemsDAO::GetByAlias($result['alias']); } catch (ApiException $e) { header('HTTP/1.1 404 Not Found'); die(file_get_contents('../404.html')); } $smarty->assign('problem_statement', $result['problem_statement']); $smarty->assign('problem_statement_language', $result['problem_statement_language']); $smarty->assign('problem_alias', $result['alias']); $smarty->assign('public', $result['public']); $smarty->assign('source', $result['source']); $smarty->assign('title', $result['title']); $smarty->assign('points', $result['points']); $smarty->assign('validator', $result['validator']); $smarty->assign('time_limit', $result['time_limit'] / 1000 . 's'); $smarty->assign('validator_time_limit', $result['validator_time_limit'] / 1000 . 's'); $smarty->assign('overall_wall_time_limit', $result['overall_wall_time_limit'] / 1000 . 's'); $smarty->assign('memory_limit', $result['memory_limit'] / 1024 . 'MB'); $smarty->assign('solvers', $result['solvers']); $smarty->assign('karel_problem', count(array_intersect(explode(',', $result['languages']), array('kp', 'kj'))) == 2); if (isset($result['sample_input'])) { $smarty->assign('sample_input', $result['sample_input']); }
public static final function byUserType($user_type, $order, $mode, $offset, $rowcount, $query, $user_id, $tag, &$total) { global $conn; // Just in case. if ($mode !== 'asc' && $mode !== 'desc') { $mode = 'desc'; } // Use BINARY mode to force case sensitive comparisons when ordering by title. $collation = $order === 'title' ? 'COLLATE utf8_bin' : ''; $select = ''; $sql = ''; $args = array(); if ($user_type === USER_ADMIN) { $args = array($user_id); $select = ' SELECT 100 / LOG2(GREATEST(accepted, 1) + 1) AS points, accepted / GREATEST(1, submissions) AS ratio, ROUND(100 * COALESCE(ps.score, 0)) AS score, p.*'; $sql = ' FROM Problems p LEFT JOIN ( SELECT Problems.problem_id, MAX(Runs.score) AS score FROM Problems INNER JOIN Runs ON Runs.user_id = ? AND Runs.problem_id = Problems.problem_id GROUP BY Problems.problem_id ) ps ON ps.problem_id = p.problem_id'; $added_where = false; if (!is_null($tag)) { $sql .= ' INNER JOIN Problems_Tags pt ON pt.problem_id = p.problem_id'; $sql .= ' INNER JOIN Tags t ON pt.tag_id = t.tag_id'; $sql .= ' WHERE t.name = ?'; $args[] = $tag; $added_where = true; } if (!is_null($query)) { if (!$added_where) { $sql .= ' WHERE'; } else { $sql .= ' AND'; } $sql .= " title LIKE CONCAT('%', ?, '%') "; $args[] = $query; } } elseif ($user_type === USER_NORMAL && !is_null($user_id)) { $select = ' SELECT 100 / LOG2(GREATEST(p.accepted, 1) + 1) AS points, p.accepted / GREATEST(1, p.submissions) AS ratio, ROUND(100 * COALESCE(ps.score, 0), 2) AS score, p.*'; $sql = ' FROM Problems p LEFT JOIN ( SELECT pi.problem_id, MAX(r.score) AS score FROM Problems pi INNER JOIN Runs r ON r.user_id = ? AND r.problem_id = pi.problem_id GROUP BY pi.problem_id ) ps ON ps.problem_id = p.problem_id LEFT JOIN User_Roles ur ON ur.user_id = ? AND p.problem_id = ur.contest_id LEFT JOIN Groups_Users gu ON gu.user_id = ? LEFT JOIN Group_Roles gr ON gr.group_id = gu.group_id AND p.problem_id = gr.contest_id'; $args[] = $user_id; $args[] = $user_id; $args[] = $user_id; if (!is_null($tag)) { $sql .= ' INNER JOIN Problems_Tags pt ON pt.problem_id = p.problem_id'; $sql .= ' INNER JOIN Tags t ON pt.tag_id = t.tag_id'; $sql .= ' WHERE t.name = ? AND pt.public = 1 AND'; $args[] = $tag; } else { $sql .= ' WHERE'; } $sql .= ' (p.public = 1 OR p.author_id = ? OR ur.role_id = 3 OR gr.role_id = 3) '; $args[] = $user_id; if (!is_null($query)) { $sql .= " AND p.title LIKE CONCAT('%', ?, '%')"; $args[] = $query; } } elseif ($user_type === USER_ANONYMOUS) { $select = ' SELECT 0 AS score, 100 / LOG2(GREATEST(p.accepted, 1) + 1) AS points, accepted / GREATEST(1, p.submissions) AS ratio, p.*'; $sql = ' FROM Problems p'; if (!is_null($tag)) { $sql .= ' INNER JOIN Problems_Tags pt ON pt.problem_id = p.problem_id'; $sql .= ' INNER JOIN Tags t ON pt.tag_id = t.tag_id'; $sql .= ' WHERE t.name = ? AND pt.public = 1 AND'; $args[] = $tag; } else { $sql .= ' WHERE'; } $sql .= ' p.public = 1 '; if (!is_null($query)) { $sql .= " AND p.title LIKE CONCAT('%', ?, '%') "; $args[] = $query; } } $total = $conn->GetOne("SELECT COUNT(*) {$sql}", $args); // Reset the offset to 0 if out of bounds. if ($offset < 0 || $offset > $total) { $offset = 0; } if ($order == 'problem_id') { $sql .= " ORDER BY p.problem_id {$collation} {$mode}"; } elseif ($order == 'points' && $mode == 'desc') { $sql .= ' ORDER BY `points` DESC, `accepted` ASC, `submissions` DESC'; } else { $sql .= " ORDER BY `{$order}` {$collation} {$mode}"; } $sql .= ' LIMIT ?, ?'; $args[] = $offset; $args[] = $rowcount; $result = $conn->Execute("{$select} {$sql}", $args); // Only these fields (plus score, points and ratio) will be returned. $filters = array('title', 'submissions', 'accepted', 'alias', 'public'); $problems = array(); if (!is_null($result)) { foreach ($result as $row) { $temp = new Problems($row); $problem = $temp->asFilteredArray($filters); // score, points and ratio are not actually fields of a Problems object. $problem['score'] = $row['score']; $problem['points'] = $row['points']; $problem['ratio'] = $row['ratio']; $problem['tags'] = ProblemsDAO::getTagsForProblem($temp, true); array_push($problems, $problem); } } return $problems; }
private static function clarificationUpdated(Request $r, $time) { try { if (is_null($r['problem'])) { $r['problem'] = ProblemsDAO::GetByPK($r['clarification']->problem_id); } if (is_null($r['contest']) && !is_null($r['clarification']->contest_id)) { $r['contest'] = ContestsDAO::GetByPK($r['clarification']->contest_id); } if (is_null($r['user'])) { $r['user'] = UsersDAO::GetByPK($r['clarification']->author_id); } } catch (Exception $e) { self::$log->error("Failed to broadcast clarification: " . $e); return; } self::$broadcaster->broadcastClarification($r, $time); }
/** * Tests removed problem admin can't edit a problem anymore * * @expectedException ForbiddenAccessException */ public function testUpdateProblemWithRemovedProblemAdmin() { // Get a problem $problemData = ProblemsFactory::createProblem(); // Create our new admin $problemAdmin = UserFactory::createUser(); // Add admin to the problem $response = ProblemController::apiAddAdmin(new Request(array('usernameOrEmail' => $problemAdmin->username, 'problem_alias' => $problemData['request']['alias'], 'auth_token' => $this->login($problemData['author'])))); $this->assertEquals('ok', $response['status']); // Then remove the user $response = ProblemController::apiRemoveAdmin(new Request(array('usernameOrEmail' => $problemAdmin->username, 'problem_alias' => $problemData['request']['alias'], 'auth_token' => $this->login($problemData['author'])))); $this->assertEquals('ok', $response['status']); //Call API $newTitle = 'new title coadmin'; $response = ProblemController::apiUpdate(new Request(array('problem_alias' => $problemData['request']['alias'], 'title' => $newTitle, 'message' => 'Non-admin powers', 'auth_token' => $this->login($problemAdmin)))); // Verify data in DB $problem_mask = new Problems(); $problem_mask->setTitle($newTitle); $problems = ProblemsDAO::search($problem_mask); }
/** * Tests removed problem admin can't edit a problem anymore * * @expectedException ForbiddenAccessException */ public function testUpdateProblemWithRemovedProblemAdmin() { // Get a problem $problemData = ProblemsFactory::createProblem(); // Create our new admin $problemAdmin = UserFactory::createUser(); // Add admin to the problem $response = ProblemController::apiAddAdmin(new Request(array("usernameOrEmail" => $problemAdmin->username, "problem_alias" => $problemData["request"]["alias"], "auth_token" => $this->login($problemData["author"])))); $this->assertEquals("ok", $response["status"]); // Then remove the user $response = ProblemController::apiRemoveAdmin(new Request(array("usernameOrEmail" => $problemAdmin->username, "problem_alias" => $problemData["request"]["alias"], "auth_token" => $this->login($problemData["author"])))); $this->assertEquals("ok", $response["status"]); //Call API $newTitle = "new title coadmin"; $response = ProblemController::apiUpdate(new Request(array("problem_alias" => $problemData["request"]["alias"], "title" => $newTitle, "message" => 'Non-admin powers', "auth_token" => $this->login($problemAdmin)))); // Verify data in DB $problem_mask = new Problems(); $problem_mask->setTitle($newTitle); $problems = ProblemsDAO::search($problem_mask); }
/** * Basic new run test */ public function testNewRunValid() { $r = $this->setValidRequest(); $this->detourGraderCalls(); // Call API $response = RunController::apiCreate($r); $this->assertRun($r, $response); // Check problem submissions (1) $problem = ProblemsDAO::getByAlias($r["problem_alias"]); $this->assertEquals(1, $problem->getSubmissions()); }
/** * Validator for List API * * @param Request $r * @throws ForbiddenAccessException * @throws InvalidDatabaseOperationException * @throws NotFoundException */ private static function validateList(Request $r) { // Defaults for offset and rowcount if (!isset($r['offset'])) { $r['offset'] = 0; } if (!isset($r['rowcount'])) { $r['rowcount'] = 100; } if (!Authorization::IsSystemAdmin($r['current_user_id'])) { throw new ForbiddenAccessException('userNotAllowed'); } Validators::isNumber($r['offset'], 'offset', false); Validators::isNumber($r['rowcount'], 'rowcount', false); Validators::isInEnum($r['status'], 'status', array('new', 'waiting', 'compiling', 'running', 'ready'), false); Validators::isInEnum($r['verdict'], 'verdict', array('AC', 'PA', 'WA', 'TLE', 'MLE', 'OLE', 'RTE', 'RFE', 'CE', 'JE', 'NO-AC'), false); // Check filter by problem, is optional if (!is_null($r['problem_alias'])) { Validators::isStringNonEmpty($r['problem_alias'], 'problem'); try { $r['problem'] = ProblemsDAO::getByAlias($r['problem_alias']); } catch (Exception $e) { // Operation failed in the data layer throw new InvalidDatabaseOperationException($e); } if (is_null($r['problem'])) { throw new NotFoundException('problemNotFound'); } } Validators::isInEnum($r['language'], 'language', array('c', 'cpp', 'cpp11', 'java', 'py', 'rb', 'pl', 'cs', 'pas', 'kp', 'kj', 'cat', 'hs'), false); // Get user if we have something in username if (!is_null($r['username'])) { try { $r['user'] = UserController::resolveUser($r['username']); } catch (NotFoundException $e) { // If not found, simply ignore it $r['username'] = null; $r['user'] = null; } } }
/** * Get Problems solved by user * * @param Request $r * @return Problems array * @throws InvalidDatabaseOperationException */ public static function apiProblemsSolved(Request $r) { self::authenticateOrAllowUnauthenticatedRequest($r); $response = array(); $response['problems'] = array(); $user = self::resolveTargetUser($r); try { $db_results = ProblemsDAO::getProblemsSolved($user->getUserId()); } catch (Exception $e) { throw new InvalidDatabaseOperationException($e); } if (!is_null($db_results)) { $relevant_columns = array('title', 'alias', 'submissions', 'accepted'); foreach ($db_results as $problem) { if ($problem->getPublic() == 1) { array_push($response['problems'], $problem->asFilteredArray($relevant_columns)); } } } $response['status'] = 'ok'; return $response; }
/** * * Gets a list of problems where current user is the owner * * @param Request $r */ public static function apiMyList(Request $r) { self::authenticateRequest($r); self::validateList($r); $response = array(); $response['results'] = array(); try { $problems = null; if (Authorization::IsSystemAdmin($r['current_user_id'])) { $problems = ProblemsDAO::getAll(null, null, 'problem_id', 'DESC'); } else { $problem_mask = new Problems(array('author_id' => $r['current_user_id'])); $problems = ProblemsDAO::search($problem_mask, 'problem_id', 'DESC', $r['offset'], $r['rowcount']); } foreach ($problems as $problem) { $problemArray = $problem->asArray(); $problemArray['tags'] = ProblemsDAO::getTagsForProblem($problem, false); array_push($response['results'], $problemArray); } } catch (Exception $e) { throw new InvalidDatabaseOperationException($e); } $response['status'] = 'ok'; return $response; }
/** * Test that we can produce a valid alias from the title */ public function testConstructAliasFromTitle() { // Get the problem data $problemData = ProblemsFactory::getRequest(); $r = $problemData['request']; $problemAuthor = $problemData['author']; // Set a valid "complex" title $r['title'] = 'Lá Venganza Del Malvado Dr. Liraaa'; // Login user $r['auth_token'] = $this->login($problemAuthor); // Get File Uploader Mock and tell Omegaup API to use it FileHandler::SetFileUploader($this->createFileUploaderMock()); // Call the API $response = ProblemController::apiCreate($r); // Validate // Verify response $this->assertEquals('ok', $response['status']); $this->assertEquals('testplan', $response['uploaded_files'][10]); // Verify data in DB $problem_mask = new Problems(); $problem_mask->setTitle($r['title']); $problems = ProblemsDAO::search($problem_mask); // Check that we only retreived 1 element $this->assertEquals(1, count($problems)); $problem = $problems[0]; // Verify contest was found $this->assertNotNull($problem); $this->assertNotNull($problem->getProblemId()); // Verify DB data $this->assertEquals($r['title'], $problem->getTitle()); // Verify problem contents were copied $targetpath = PROBLEMS_PATH . DIRECTORY_SEPARATOR . $problem->getAlias() . DIRECTORY_SEPARATOR; $this->assertFileExists($targetpath . 'testplan'); $this->assertFileExists($targetpath . 'cases'); $this->assertFileExists($targetpath . 'statements' . DIRECTORY_SEPARATOR . 'en.html'); }
/** * * Gets a list of problems where current user is the owner * * @param Request $r */ public static function apiMyList(Request $r) { self::authenticateRequest($r); self::validateList($r); $response = array(); $response["results"] = array(); try { $problems = NULL; if (Authorization::IsSystemAdmin($r["current_user_id"])) { $problems = ProblemsDAO::getAll(NULL, NULL, "problem_id", 'DESC'); } else { $problem_mask = new Problems(array("author_id" => $r["current_user_id"])); $problems = ProblemsDAO::search($problem_mask, "problem_id", 'DESC', $r["offset"], $r["rowcount"]); } foreach ($problems as $problem) { $problemArray = $problem->asArray(); $problemArray['tags'] = ProblemsDAO::getTagsForProblem($problem, false); array_push($response["results"], $problemArray); } } catch (Exception $e) { throw new InvalidDatabaseOperationException($e); } $response["status"] = "ok"; return $response; }