course-format-ts 1.0.0

package/src/courseFormat/LessonContainer.ts

@@ -0,0 +1,65 @@
+import { ItemContainer } from "./ItemContainer"
+import type { Lesson } from "./Lesson"
+import type { Section } from "./Section"
+import { Task } from "./tasks/Task"
+
+function getLessonModule(): { Lesson: typeof Lesson; Section: typeof Section } {
+  // eslint-disable-next-line @typescript-eslint/no-var-requires
+  const SectionModule = require("./Section")
+  // eslint-disable-next-line @typescript-eslint/no-var-requires
+  const LessonModule = require("./Lesson")
+  return { Lesson: LessonModule.Lesson, Section: SectionModule.Section }
+}
+
+export abstract class LessonContainer extends ItemContainer {
+  get lessons(): Lesson[] {
+    const mod = getLessonModule()
+    return this.items.filter((item): item is Lesson => item instanceof mod.Lesson)
+  }
+
+  getLesson(name: string): Lesson | undefined
+  getLesson(id: number): Lesson | undefined
+  getLesson(check: (lesson: Lesson) => boolean): Lesson | undefined
+  getLesson(param: string | number | ((lesson: Lesson) => boolean)): Lesson | undefined {
+    if (typeof param === "string") {
+      return this.getLesson((lesson) => lesson.name === param)
+    }
+    if (typeof param === "number") {
+      return this.getLesson((lesson) => lesson.id === param)
+    }
+    return this.lessons.find(param)
+  }
+
+  addLessons(lessons: Lesson[]): void {
+    lessons.forEach((lesson) => this.addItem(lesson))
+  }
+
+  addLesson(lesson: Lesson): void {
+    this.addItem(lesson)
+  }
+
+  removeLesson(lesson: Lesson): void {
+    this.removeItem(lesson)
+  }
+
+  visitLessons(visit: (lesson: Lesson) => void): void {
+    const mod = getLessonModule()
+    for (const item of this.items) {
+      if (item instanceof mod.Lesson) {
+        visit(item)
+      }
+      else if (item instanceof mod.Section) {
+        item.lessons.forEach(visit)
+      }
+    }
+  }
+
+  visitSections(visit: (section: Section) => void): void {
+    const mod = getLessonModule()
+    this.items.filter((item): item is Section => item instanceof mod.Section).forEach(visit)
+  }
+
+  visitTasks(visit: (task: Task) => void): void {
+    this.visitLessons((lesson) => lesson.visitTasks(visit))
+  }
+}

package/src/courseFormat/PluginInfo.ts

@@ -0,0 +1,15 @@
+export class PluginInfo {
+  stringId = ""
+  displayName?: string
+  minVersion?: string
+  maxVersion?: string
+
+  constructor(stringId?: string, displayName?: string | null, minVersion?: string | null, maxVersion?: string | null) {
+    if (stringId !== undefined) {
+      this.stringId = stringId
+    }
+    this.displayName = displayName ?? undefined
+    this.minVersion = minVersion ?? undefined
+    this.maxVersion = maxVersion ?? undefined
+  }
+}

package/src/courseFormat/Section.ts

@@ -0,0 +1,29 @@
+import { LessonContainer } from "./LessonContainer"
+import type { Course } from "./Course"
+import { SECTION } from "./EduFormatNames"
+import { ItemContainer } from "./ItemContainer"
+
+function getCourseModule(): { Course: typeof Course } {
+  // eslint-disable-next-line @typescript-eslint/no-var-requires
+  return require("./Course")
+}
+
+export class Section extends LessonContainer {
+  override init(parentItem: ItemContainer, isRestarted: boolean): void {
+    if (!(parentItem instanceof getCourseModule().Course)) {
+      throw new Error(`Course is null for section ${this.name}`)
+    }
+    super.init(parentItem, isRestarted)
+  }
+
+  get course(): Course {
+    if (!(this.parent instanceof getCourseModule().Course)) {
+      throw new Error(`Course is null for section ${this.name}`)
+    }
+    return this.parent as Course
+  }
+
+  get itemType(): string {
+    return SECTION
+  }
+}

package/src/courseFormat/StudyItem.ts

@@ -0,0 +1,55 @@
+import { ItemContainer } from "./ItemContainer"
+import type { Course } from "./Course"
+
+export abstract class StudyItem {
+  index = -1
+  name = ""
+  updateDate: Date = new Date(0)
+  id = 0
+  contentTags: string[] = []
+  customPresentableName?: string
+  protected _parent?: ItemContainer
+
+  constructor(name?: string) {
+    if (name) {
+      this.name = name
+    }
+  }
+
+  get parent(): ItemContainer {
+    if (!this._parent) {
+      throw new Error(`Parent is null for StudyItem ${this.name}`)
+    }
+    return this._parent
+  }
+
+  set parent(value: ItemContainer) {
+    this._parent = value
+  }
+
+  get presentableName(): string {
+    return this.customPresentableName ?? this.name
+  }
+
+  abstract get course(): Course
+  abstract get itemType(): string
+  abstract init(parentItem: ItemContainer, isRestarted: boolean): void
+
+  getRelativePath(root: StudyItem): string {
+    if (this === root) return ""
+    const parents: string[] = []
+    let currentParent = this.parent
+    while (currentParent !== root) {
+      parents.push(currentParent.name)
+      currentParent = currentParent.parent
+    }
+    parents.reverse()
+    if (parents.length === 0) return this.name
+    parents.push(this.name)
+    return parents.join("/")
+  }
+
+  get pathInCourse(): string {
+    return this.getRelativePath(this.course)
+  }
+}

package/src/courseFormat/Tags.ts

@@ -0,0 +1,45 @@
+import { message } from "./uiMessages"
+
+const PROGRAMMING_LANGUAGE_TAG_SEARCH_OPTION = "programming_language"
+const LANGUAGE_TAG_SEARCH_OPTION = "language"
+
+export class Tag {
+  readonly text: string
+  private readonly searchOption: string
+
+  constructor(text: string, searchOption = "tag") {
+    this.text = text
+    this.searchOption = searchOption
+  }
+
+  getSearchText(): string {
+    return `${this.searchOption}:${this.text}`.toLowerCase()
+  }
+
+  accept(filter: string): boolean {
+    const textInLowerCase = this.text.toLowerCase()
+    if (textInLowerCase.includes(filter)) {
+      return true
+    }
+    const searchPrefix = `${this.searchOption}:`
+    return filter.startsWith(searchPrefix) && textInLowerCase.includes(filter.substring(searchPrefix.length))
+  }
+}
+
+export class ProgrammingLanguageTag extends Tag {
+  constructor(language: string) {
+    super(language, PROGRAMMING_LANGUAGE_TAG_SEARCH_OPTION)
+  }
+}
+
+export class HumanLanguageTag extends Tag {
+  constructor(languageName: string) {
+    super(languageName, LANGUAGE_TAG_SEARCH_OPTION)
+  }
+}
+
+export class FeaturedTag extends Tag {
+  constructor() {
+    super(message("course.dialog.tags.featured"))
+  }
+}

package/src/courseFormat/TaskFile.ts

@@ -0,0 +1,88 @@
+import { EduFile } from "./EduFile"
+import { AnswerPlaceholder } from "./AnswerPlaceholder"
+import { AnswerPlaceholderComparator } from "./AnswerPlaceholderComparator"
+import { CheckStatus } from "./CheckStatus"
+import type { Task } from "./tasks/Task"
+import { FileContents } from "./FileContents"
+
+export class TaskFile extends EduFile {
+  private _answerPlaceholders: AnswerPlaceholder[] = []
+  private _task?: Task
+  override isVisible = true
+
+  constructor()
+  constructor(name: string, text: string)
+  constructor(name: string, contents: FileContents)
+  constructor(name: string, text: string, isVisible: boolean)
+  constructor(name: string, text: string, isVisible: boolean, isLearnerCreated: boolean)
+  constructor(name?: string, textOrContents?: string | FileContents, isVisible?: boolean, isLearnerCreated?: boolean) {
+    super()
+    if (name !== undefined) this.name = name
+    if (typeof textOrContents === "string") {
+      this.text = textOrContents
+    }
+    else if (textOrContents) {
+      this.contents = textOrContents
+    }
+    if (isVisible !== undefined) this.isVisible = isVisible
+    if (isLearnerCreated !== undefined) this.isLearnerCreated = isLearnerCreated
+  }
+
+  get answerPlaceholders(): AnswerPlaceholder[] {
+    return this._answerPlaceholders
+  }
+
+  set answerPlaceholders(value: AnswerPlaceholder[]) {
+    this._answerPlaceholders = [...value]
+  }
+
+  get task(): Task {
+    if (!this._task) {
+      throw new Error(`Task is null for TaskFile ${this.name}`)
+    }
+    return this._task
+  }
+
+  set task(value: Task) {
+    this._task = value
+  }
+
+  initTaskFile(task: Task, isRestarted: boolean): void {
+    this.task = task
+    for (const answerPlaceholder of this._answerPlaceholders) {
+      answerPlaceholder.init(this, isRestarted)
+    }
+    this.sortAnswerPlaceholders()
+  }
+
+  addAnswerPlaceholder(answerPlaceholder: AnswerPlaceholder): void {
+    this._answerPlaceholders.push(answerPlaceholder)
+  }
+
+  removeAnswerPlaceholder(answerPlaceholder: AnswerPlaceholder): void {
+    this._answerPlaceholders = this._answerPlaceholders.filter((item) => item !== answerPlaceholder)
+  }
+
+  getAnswerPlaceholder(offset: number): AnswerPlaceholder | undefined {
+    return this._answerPlaceholders.find((placeholder) => offset >= placeholder.offset && offset <= placeholder.endOffset)
+  }
+
+  removeAllPlaceholders(): void {
+    this._answerPlaceholders = []
+  }
+
+  sortAnswerPlaceholders(): void {
+    this._answerPlaceholders.sort(AnswerPlaceholderComparator.compare)
+    this._answerPlaceholders.forEach((placeholder, index) => {
+      placeholder.index = index
+    })
+  }
+
+  hasFailedPlaceholders(): boolean {
+    return this._answerPlaceholders.some((placeholder) => placeholder.status === CheckStatus.Failed)
+  }
+
+  isValid(text: string): boolean {
+    return this._answerPlaceholders.every((placeholder) => placeholder.isValid(text.length))
+  }
+}

package/src/courseFormat/UserInfo.ts

@@ -0,0 +1,3 @@
+export interface UserInfo {
+  getFullName(): string
+}

package/src/courseFormat/Vendor.ts

@@ -0,0 +1,15 @@
+export class Vendor {
+  readonly name: string
+  readonly email?: string
+  readonly url?: string
+
+  constructor(name = "", email?: string | null, url?: string | null) {
+    this.name = name
+    this.email = email ?? undefined
+    this.url = url ?? undefined
+  }
+
+  toString(): string {
+    return this.name
+  }
+}

package/src/courseFormat/attempts/Attempt.ts

@@ -0,0 +1,28 @@
+import { AttemptBase } from "./AttemptBase"
+import { Dataset } from "./Dataset"
+
+export class Attempt extends AttemptBase {
+  step = 0
+  dataset: Dataset | null = null
+  status: string | null = null
+  user: string | null = null
+
+  get isActive(): boolean {
+    return this.status === "active"
+  }
+
+  constructor()
+  constructor(step: number)
+  constructor(id: number, time: Date, timeLeft: number)
+  constructor(stepOrId?: number, time?: Date, timeLeft?: number) {
+    super()
+    if (stepOrId !== undefined && time === undefined) {
+      this.step = stepOrId
+    }
+    else if (stepOrId !== undefined && time !== undefined) {
+      this.id = stepOrId
+      this.time = time
+      this.timeLeft = timeLeft ?? null
+    }
+  }
+}

package/src/courseFormat/attempts/AttemptBase.ts

@@ -0,0 +1,24 @@
+export abstract class AttemptBase {
+  id = 0
+  time: Date = new Date()
+  timeLeft: number | null = null
+
+  get isRunning(): boolean {
+    const endDateTime = this.calculateEndDateTime()
+    if (endDateTime === null) return true
+    return new Date() < endDateTime
+  }
+
+  protected calculateEndDateTime(): Date | null {
+    if (this.timeLeft === null) return null
+    return new Date(this.time.getTime() + this.timeLeft * 1000)
+  }
+
+  constructor()
+  constructor(id: number, time: Date, timeLeft: number | null)
+  constructor(id?: number, time?: Date, timeLeft?: number | null) {
+    if (id !== undefined) this.id = id
+    if (time !== undefined) this.time = time
+    if (timeLeft !== undefined) this.timeLeft = timeLeft
+  }
+}

package/src/courseFormat/attempts/DataTaskAttempt.ts

@@ -0,0 +1,19 @@
+import { AttemptBase } from "./AttemptBase"
+
+export class DataTaskAttempt extends AttemptBase {
+  endDateTime: Date | null = null
+
+  override get isRunning(): boolean {
+    if (this.endDateTime === null) return true
+    return new Date() < this.endDateTime
+  }
+
+  static fromAttempt(attempt: AttemptBase): DataTaskAttempt {
+    const result = new DataTaskAttempt()
+    result.id = attempt.id
+    result.time = attempt.time
+    result.timeLeft = attempt.timeLeft
+    result.endDateTime = result.calculateEndDateTime()
+    return result
+  }
+}

package/src/courseFormat/attempts/Dataset.ts

@@ -0,0 +1,13 @@
+export class Dataset {
+  isMultipleChoice = false
+  options: string[] | null = null
+  pairs: Pair[] | null = null
+  rows: string[] | null = null
+  columns: string[] | null = null
+  isCheckbox = false
+}
+
+export class Pair {
+  first = ""
+  second = ""
+}

package/src/courseFormat/fileUtils.ts

@@ -0,0 +1,31 @@
+import { lookup } from "mime-types"
+import { logger } from "./loggerUtils"
+
+const mimeBinaryTypes = ["image", "audio", "video", "application", "font"].map((type) => `${type}/`)
+
+export function isBinary(contentType: string): boolean {
+  return mimeBinaryTypes.some((prefix) => contentType.startsWith(prefix))
+}
+
+export function mimeFileType(path: string): string | false | undefined {
+  try {
+    return lookup(path)
+  }
+  catch (error) {
+    logger("fileUtils").error("Failed to determine file mimetype", error)
+    return undefined
+  }
+}
+
+export function exceedsBase64ContentLimit(base64text: string): boolean {
+  return Buffer.from(base64text, "utf16le").byteLength > getBinaryFileLimit()
+}
+
+export function getBinaryFileLimit(): number {
+  return 1024 * 1024
+}
+
+export function getExtension(fileName: string): string {
+  const index = fileName.lastIndexOf(".")
+  return index < 0 ? "" : fileName.substring(index + 1)
+}

package/src/courseFormat/hyperskill/HyperskillCourse.ts

@@ -0,0 +1,24 @@
+import { Course } from "../Course"
+import { HyperskillProject } from "./HyperskillProject"
+import { HyperskillStage } from "./HyperskillStage"
+import { HyperskillTopic } from "./HyperskillTopic"
+import { HYPERSKILL } from "../EduFormatNames"
+
+export class HyperskillCourse extends Course {
+  taskToTopics: Map<number, HyperskillTopic[]> = new Map()
+  stages: HyperskillStage[] = []
+  hyperskillProject: HyperskillProject | null = null
+  selectedStage: number | null = null
+  selectedProblem: number | null = null
+
+  override get itemType(): string {
+    return HYPERSKILL
+  }
+
+  get isTemplateBased(): boolean {
+    if (!this.hyperskillProject) {
+      throw new Error("Disconnected Hyperskill project")
+    }
+    return this.hyperskillProject.isTemplateBased
+  }
+}

package/src/courseFormat/hyperskill/HyperskillProject.ts

@@ -0,0 +1,10 @@
+export class HyperskillProject {
+  id = -1
+  title = ""
+  description = ""
+  ideFiles = ""
+  useIde = true
+  language = ""
+  environment: string | null = null
+  isTemplateBased = false
+}

package/src/courseFormat/hyperskill/HyperskillStage.ts

@@ -0,0 +1,15 @@
+export class HyperskillStage {
+  id = -1
+  title = ""
+  stepId = -1
+  isCompleted = false
+
+  constructor()
+  constructor(stageId: number, stageTitle: string, stageStepId: number, isStageCompleted: boolean)
+  constructor(stageId?: number, stageTitle?: string, stageStepId?: number, isStageCompleted?: boolean) {
+    if (stageId !== undefined) this.id = stageId
+    if (stageTitle !== undefined) this.title = stageTitle
+    if (stageStepId !== undefined) this.stepId = stageStepId
+    if (isStageCompleted !== undefined) this.isCompleted = isStageCompleted
+  }
+}

package/src/courseFormat/hyperskill/HyperskillTaskType.ts

@@ -0,0 +1,23 @@
+/**
+ * Maps Hyperskill task type IDs to their human-readable labels.
+ */
+export const HYPERSKILL_TASK_TYPE_LABELS: Record<string, string> = {
+  admin: "Linux",
+  choice: "Quiz",
+  code: "Programming",
+  dataset: "Data",
+  "fill-blanks": "Fill Blanks",
+  "free-answer": "Free Response",
+  "manual-score": "Manual Score",
+  matching: "Matching",
+  math: "Math",
+  number: "Number",
+  parsons: "Parsons",
+  pycharm: "Programming",
+  remote_edu: "Programming",
+  sorting: "Sorting",
+  string: "Text",
+  table: "Table",
+  text: "Theory",
+  video: "Video",
+}

package/src/courseFormat/hyperskill/HyperskillTopic.ts

@@ -0,0 +1,5 @@
+export class HyperskillTopic {
+  id = -1
+  title = ""
+  theoryId: number | null = null
+}

package/src/courseFormat/loggerUtils.ts

@@ -0,0 +1,3 @@
+export function logger(name: string): Console {
+  return console
+}

package/src/courseFormat/stepik/StepikCourse.ts

@@ -0,0 +1,10 @@
+import { EduCourse } from "../EduCourse"
+import { STEPIK } from "../EduFormatNames"
+
+export class StepikCourse extends EduCourse {
+  isAdaptive = false
+
+  override get itemType(): string {
+    return STEPIK
+  }
+}

package/src/courseFormat/stepik/StepikLesson.ts

@@ -0,0 +1,11 @@
+import { Lesson } from "../Lesson"
+import { STEPIK } from "../EduFormatNames"
+
+export class StepikLesson extends Lesson {
+  stepIds: number[] = []
+  unitId = 0
+
+  override get itemType(): string {
+    return STEPIK
+  }
+}

package/src/courseFormat/tasks/AnswerTask.ts

@@ -0,0 +1,13 @@
+import { CheckStatus } from "../CheckStatus"
+import { Task } from "./Task"
+
+export abstract class AnswerTask extends Task {
+  static ANSWER_FILE_NAME = "answer.txt"
+
+  constructor()
+  constructor(name: string)
+  constructor(name: string, id: number, position: number, updateDate: Date, status: CheckStatus)
+  constructor(name?: string, id?: number, position?: number, updateDate?: Date, status?: CheckStatus) {
+    super(name as string, id as number, position as number, updateDate as Date, status as CheckStatus)
+  }
+}

package/src/courseFormat/tasks/CodeTask.ts

@@ -0,0 +1,42 @@
+import { CheckStatus } from "../CheckStatus"
+import { Task } from "./Task"
+
+export class CodeTask extends Task {
+  submissionLanguage?: string
+
+  constructor()
+  constructor(name: string)
+  constructor(
+    name: string,
+    id: number,
+    position: number,
+    updateDate: Date,
+    status: CheckStatus,
+    submissionLanguage?: string | null
+  )
+  constructor(
+    name?: string,
+    id?: number,
+    position?: number,
+    updateDate?: Date,
+    status?: CheckStatus,
+    submissionLanguage?: string | null
+  ) {
+    super(name as string, id as number, position as number, updateDate as Date, status as CheckStatus)
+    this.submissionLanguage = submissionLanguage ?? undefined
+  }
+
+  get itemType(): string {
+    return CodeTask.CODE_TASK_TYPE
+  }
+
+  get supportSubmissions(): boolean {
+    return true
+  }
+
+  get isPluginTaskType(): boolean {
+    return false
+  }
+
+  static CODE_TASK_TYPE = "code"
+}

package/src/courseFormat/tasks/DataTask.ts

@@ -0,0 +1,37 @@
+import { CheckStatus } from "../CheckStatus"
+import { Task } from "./Task"
+import type { DataTaskAttempt } from "../attempts/DataTaskAttempt"
+
+export class DataTask extends Task {
+  attempt?: DataTaskAttempt
+
+  get isTimeLimited(): boolean {
+    return this.attempt?.endDateTime !== undefined
+  }
+
+  constructor()
+  constructor(name: string)
+  constructor(name: string, id: number, position: number, updateDate: Date, status: CheckStatus)
+  constructor(name?: string, id?: number, position?: number, updateDate?: Date, status?: CheckStatus) {
+    super(name as string, id as number, position as number, updateDate as Date, status as CheckStatus)
+  }
+
+  get itemType(): string {
+    return DataTask.DATA_TASK_TYPE
+  }
+
+  get supportSubmissions(): boolean {
+    return false
+  }
+
+  isRunning(): boolean {
+    if (this.status !== CheckStatus.Unchecked) return false
+    return this.attempt?.isRunning ?? false
+  }
+
+  static DATA_TASK_TYPE = "dataset"
+  static DATA_FOLDER_NAME = "data"
+  static DATA_SAMPLE_FOLDER_NAME = "sample"
+  static DATASET_FOLDER_NAME = "dataset"
+  static INPUT_FILE_NAME = "input.txt"
+}

package/src/courseFormat/tasks/EduTask.ts

@@ -0,0 +1,26 @@
+import { CheckStatus } from "../CheckStatus"
+import { Task } from "./Task"
+
+export class EduTask extends Task {
+  constructor()
+  constructor(name: string)
+  constructor(name: string, id: number, position: number, updateDate: Date, status: CheckStatus)
+  constructor(name?: string, id?: number, position?: number, updateDate?: Date, status?: CheckStatus) {
+    super(name as string, id as number, position as number, updateDate as Date, status as CheckStatus)
+  }
+
+  get itemType(): string {
+    return EduTask.EDU_TASK_TYPE
+  }
+
+  get isToSubmitToRemote(): boolean {
+    return this.checkStatus !== CheckStatus.Unchecked
+  }
+
+  get supportSubmissions(): boolean {
+    return true
+  }
+
+  static EDU_TASK_TYPE = "edu"
+  static PYCHARM_TASK_TYPE = "pycharm"
+}