@xcpcio/core 0.2.1

package/src/submission-status.ts

@@ -0,0 +1,151 @@
+import { SubmissionStatus } from "@xcpcio/types";
+
+export function stringToSubmissionStatus(status: string): SubmissionStatus {
+  status = status.toUpperCase().replace(" ", "_");
+
+  if (["OK", "AC", SubmissionStatus.ACCEPTED.toString()].includes(status)) {
+    return SubmissionStatus.ACCEPTED;
+  }
+
+  if ([SubmissionStatus.CORRECT.toString()].includes(status)) {
+    return SubmissionStatus.CORRECT;
+  }
+
+  if ([SubmissionStatus.PARTIALLY_CORRECT.toString()].includes(status)) {
+    return SubmissionStatus.PARTIALLY_CORRECT;
+  }
+
+  if (["WA", SubmissionStatus.WRONG_ANSWER.toString()].includes(status)) {
+    return SubmissionStatus.WRONG_ANSWER;
+  }
+
+  if (["RJ", "INCORRECT", SubmissionStatus.REJECTED.toString()].includes(status)) {
+    return SubmissionStatus.REJECTED;
+  }
+
+  if (["PD", SubmissionStatus.PENDING.toString()].includes(status)) {
+    return SubmissionStatus.PENDING;
+  }
+
+  if ([SubmissionStatus.WAITING.toString()].includes(status)) {
+    return SubmissionStatus.WAITING;
+  }
+
+  if ([SubmissionStatus.JUDGING.toString()].includes(status)) {
+    return SubmissionStatus.JUDGING;
+  }
+
+  if ([SubmissionStatus.FROZEN.toString()].includes(status)) {
+    return SubmissionStatus.FROZEN;
+  }
+
+  if (["CE", SubmissionStatus.COMPILE_ERROR.toString()].includes(status)) {
+    return SubmissionStatus.COMPILE_ERROR;
+  }
+
+  if (["PE", SubmissionStatus.PRESENTATION_ERROR.toString()].includes(status)) {
+    return SubmissionStatus.PRESENTATION_ERROR;
+  }
+
+  if (["TL", "TLE", SubmissionStatus.TIME_LIMIT_EXCEEDED.toString()].includes(status)) {
+    return SubmissionStatus.TIME_LIMIT_EXCEEDED;
+  }
+
+  if (["ML", "MLE", SubmissionStatus.MEMORY_LIMIT_EXCEEDED.toString()].includes(status)) {
+    return SubmissionStatus.MEMORY_LIMIT_EXCEEDED;
+  }
+
+  if (["OL", "OLE", SubmissionStatus.OUTPUT_LIMIT_EXCEEDED.toString()].includes(status)) {
+    return SubmissionStatus.OUTPUT_LIMIT_EXCEEDED;
+  }
+
+  if (["IL", "ILE", SubmissionStatus.IDLENESS_LIMIT_EXCEEDED.toString()].includes(status)) {
+    return SubmissionStatus.IDLENESS_LIMIT_EXCEEDED;
+  }
+
+  if (["RT", "RE", "RTE", SubmissionStatus.RUNTIME_ERROR.toString()].includes(status)) {
+    return SubmissionStatus.RUNTIME_ERROR;
+  }
+
+  if (["JE", SubmissionStatus.JUDGEMENT_FAILED.toString()].includes(status)) {
+    return SubmissionStatus.JUDGEMENT_FAILED;
+  }
+
+  if (["SE", SubmissionStatus.SYSTEM_ERROR.toString()].includes(status)) {
+    return SubmissionStatus.SYSTEM_ERROR;
+  }
+
+  if ([SubmissionStatus.HACKED.toString()].includes(status)) {
+    return SubmissionStatus.HACKED;
+  }
+
+  if ([SubmissionStatus.CONFIGURATION_ERROR.toString()].includes(status)) {
+    return SubmissionStatus.CONFIGURATION_ERROR;
+  }
+
+  if ([SubmissionStatus.CANCELED.toString()].includes(status)) {
+    return SubmissionStatus.CANCELED;
+  }
+
+  if ([SubmissionStatus.SKIPPED.toString()].includes(status)) {
+    return SubmissionStatus.SKIPPED;
+  }
+
+  if ([SubmissionStatus.SECURITY_VIOLATED.toString()].includes(status)) {
+    return SubmissionStatus.SECURITY_VIOLATED;
+  }
+
+  if ([SubmissionStatus.DENIAL_OF_JUDGEMENT.toString()].includes(status)) {
+    return SubmissionStatus.DENIAL_OF_JUDGEMENT;
+  }
+
+  return SubmissionStatus.UNKNOWN;
+}
+
+export function isAccepted(status: SubmissionStatus): boolean {
+  const acceptedArray = [SubmissionStatus.ACCEPTED, SubmissionStatus.CORRECT];
+
+  return acceptedArray.includes(status);
+}
+
+export function isRejected(status: SubmissionStatus): boolean {
+  const rejectArray = [
+    SubmissionStatus.RUNTIME_ERROR,
+    SubmissionStatus.TIME_LIMIT_EXCEEDED,
+    SubmissionStatus.MEMORY_LIMIT_EXCEEDED,
+    SubmissionStatus.OUTPUT_LIMIT_EXCEEDED,
+    SubmissionStatus.IDLENESS_LIMIT_EXCEEDED,
+    SubmissionStatus.WRONG_ANSWER,
+    SubmissionStatus.REJECTED,
+    SubmissionStatus.JUDGEMENT_FAILED,
+    SubmissionStatus.HACKED,
+  ];
+
+  return rejectArray.includes(status);
+}
+
+export function isPending(status: SubmissionStatus): boolean {
+  const pendingArray = [
+    SubmissionStatus.PENDING,
+    SubmissionStatus.WAITING,
+    SubmissionStatus.JUDGING,
+    SubmissionStatus.FROZEN,
+  ];
+
+  return pendingArray.includes(status);
+}
+
+export function isNotCalculatedPenaltyStatus(status: SubmissionStatus): boolean {
+  const isNotCalculatedPenaltyArray = [
+    SubmissionStatus.COMPILE_ERROR,
+    SubmissionStatus.PRESENTATION_ERROR,
+    SubmissionStatus.CONFIGURATION_ERROR,
+    SubmissionStatus.SYSTEM_ERROR,
+    SubmissionStatus.CANCELED,
+    SubmissionStatus.SKIPPED,
+    SubmissionStatus.UNKNOWN,
+    SubmissionStatus.UNDEFINED,
+  ];
+
+  return isNotCalculatedPenaltyArray.includes(status);
+}

package/src/submission.ts

@@ -0,0 +1,87 @@
+import { Submission as ISubmission, Submissions as ISubmissions, SubmissionStatus } from "@xcpcio/types";
+
+import {
+  isAccepted,
+  isRejected,
+  isPending,
+  isNotCalculatedPenaltyStatus,
+  stringToSubmissionStatus,
+} from "./submission-status";
+
+export class Submission {
+  id: string;
+  teamId: string;
+  problemId: string;
+  timestamp: number;
+
+  status = SubmissionStatus.UNKNOWN;
+  isIgnore = false;
+
+  constructor() {
+    this.id = "";
+    this.teamId = "";
+    this.problemId = "";
+    this.timestamp = 0;
+  }
+
+  isAccepted() {
+    return isAccepted(this.status);
+  }
+
+  isRejected() {
+    return isRejected(this.status);
+  }
+
+  isPending() {
+    return isPending(this.status);
+  }
+
+  isNotCalculatedPenaltyStatus() {
+    return isNotCalculatedPenaltyStatus(this.status);
+  }
+
+  static compare(lhs: Submission, rhs: Submission): number {
+    if (lhs.timestamp !== rhs.timestamp) {
+      return lhs.timestamp - rhs.timestamp;
+    }
+
+    if (lhs.teamId === rhs.teamId) {
+      if (lhs.isAccepted() && !rhs.isAccepted()) {
+        return -1;
+      }
+
+      if (!lhs.isAccepted() && rhs.isAccepted()) {
+        return 1;
+      }
+    }
+
+    return 0;
+  }
+}
+
+export type Submissions = Array<Submission>;
+
+export function createSubmission(submissionJSON: ISubmission): Submission {
+  const s = new Submission();
+
+  s.id = String(submissionJSON.id ?? submissionJSON.submission_id ?? "");
+  s.teamId = String(submissionJSON.team_id);
+  s.problemId = String(submissionJSON.problem_id);
+  s.timestamp = submissionJSON.timestamp;
+  s.status = stringToSubmissionStatus(submissionJSON.status);
+  s.isIgnore = submissionJSON.is_ignore ?? false;
+
+  return s;
+}
+
+export function createSubmissions(submissionsJSON: ISubmissions): Submissions {
+  if (Array.isArray(submissionsJSON)) {
+    return submissionsJSON.map((s, index) => createSubmission({ ...s, id: s.submission_id ?? String(index) }));
+  } else {
+    const submissions = Object.entries(submissionsJSON).map(([submissionId, s]) =>
+      createSubmission({ ...s, id: s.submission_id ?? submissionId }),
+    );
+
+    return submissions;
+  }
+}

package/src/team.ts

@@ -0,0 +1,116 @@
+import { Team as ITeam, Teams as ITeams } from "@xcpcio/types";
+
+import { TeamProblemStatistics } from "./problem";
+
+export class Team {
+  id: string;
+  name: string;
+  organization: string;
+
+  group: Array<string>;
+  tag: Array<string>;
+
+  coach?: string | Array<string>;
+  members?: string | Array<string>;
+
+  rank: number;
+  solvedProblemNum: number;
+  penalty: number;
+
+  problemStatistics: Array<TeamProblemStatistics>;
+  problemStatisticsMap: Map<string, TeamProblemStatistics>;
+
+  constructor() {
+    this.id = "";
+    this.name = "";
+    this.organization = "";
+
+    this.group = [];
+    this.tag = [];
+
+    this.rank = 0;
+    this.solvedProblemNum = 0;
+    this.penalty = 0;
+
+    this.problemStatistics = [];
+    this.problemStatisticsMap = new Map<string, TeamProblemStatistics>();
+  }
+
+  penaltyToMinute() {
+    return Math.floor(this.penalty / 60);
+  }
+
+  calcSolvedData() {
+    this.solvedProblemNum = 0;
+    this.penalty = 0;
+
+    for (const p of this.problemStatistics) {
+      if (p.isAccepted) {
+        this.solvedProblemNum++;
+        this.penalty += p.penalty;
+      }
+    }
+  }
+
+  static compare(lhs: Team, rhs: Team): number {
+    if (lhs.solvedProblemNum !== rhs.solvedProblemNum) {
+      return rhs.solvedProblemNum - lhs.solvedProblemNum;
+    }
+
+    if (lhs.penalty !== rhs.penalty) {
+      return lhs.penalty - rhs.penalty;
+    }
+
+    if (lhs.name < rhs.name) {
+      return -1;
+    } else if (lhs.name > rhs.name) {
+      return 1;
+    }
+
+    return 0;
+  }
+}
+
+export type Teams = Array<Team>;
+
+export function createTeam(teamJSON: ITeam): Team {
+  const t = new Team();
+
+  t.id = teamJSON.id ?? teamJSON.team_id ?? "";
+  t.name = teamJSON.name ?? teamJSON.team_name ?? "";
+
+  t.organization = teamJSON.organization ?? "";
+  t.group = teamJSON.group ?? [];
+  t.tag = teamJSON.group ?? [];
+
+  t.coach = teamJSON.coach;
+  t.members = teamJSON.members;
+
+  if (teamJSON.official === true) {
+    t.group.push("official");
+  }
+
+  if (teamJSON.unofficial === true) {
+    t.group.push("unofficial");
+  }
+
+  if (teamJSON.girl === true) {
+    t.group.push("girl");
+  }
+
+  t.group = [...new Set(t.group)];
+  t.group.sort();
+
+  return t;
+}
+
+export function createTeams(teamsJSON: ITeams): Teams {
+  if (Array.isArray(teamsJSON)) {
+    return teamsJSON.map((t) => createTeam(t));
+  } else {
+    const teams = Object.entries(teamsJSON).map(([teamId, team]) =>
+      createTeam({ ...team, team_id: team.team_id ?? teamId }),
+    );
+    return teams;
+  }
+}

package/src/utils/dayjs.ts

@@ -0,0 +1,61 @@
+import dayjs from "dayjs";
+
+import duration from "dayjs/plugin/duration";
+dayjs.extend(duration);
+
+import utc from "dayjs/plugin/utc";
+dayjs.extend(utc);
+
+import timezone from "dayjs/plugin/timezone";
+dayjs.extend(timezone);
+
+import advancedFormat from "dayjs/plugin/advancedFormat";
+dayjs.extend(advancedFormat);
+
+import isSameOrBefore from "dayjs/plugin/isSameOrBefore";
+dayjs.extend(isSameOrBefore);
+
+import isSameOrAfter from "dayjs/plugin/isSameOrAfter";
+dayjs.extend(isSameOrAfter);
+
+import minMax from "dayjs/plugin/minMax";
+dayjs.extend(minMax);
+
+import relativeTime from "dayjs/plugin/relativeTime";
+dayjs.extend(relativeTime);
+
+export function createDayJS(time: Date | string | number | undefined = undefined): dayjs.Dayjs {
+  if (time === undefined) {
+    return dayjs();
+  }
+
+  if (typeof time == "number" && String(time).length === 10) {
+    return dayjs.unix(time);
+  }
+
+  return dayjs(time);
+}
+
+export function getTimestamp(time: number | dayjs.Dayjs): number {
+  if (typeof time === "number") {
+    return time;
+  }
+
+  return time.unix();
+}
+
+export function getTimeDiff(seconds: number): string {
+  const two = (a: number) => {
+    if (a < 10) return "0" + a;
+    return String(a);
+  };
+
+  const h = Math.floor(seconds / 3600);
+  const m = Math.floor((seconds % 3600) / 60);
+  const s = seconds % 60;
+
+  return [two(h), two(m), two(s)].join(":");
+}
+
+export { dayjs };
+export default dayjs;

package/src/utils/index.ts

@@ -0,0 +1 @@
+export * from "./dayjs";