course-format-ts 1.0.0

package/src/courseFormat/tasks/IdeTask.ts

@@ -0,0 +1,17 @@
+import { CheckStatus } from "../CheckStatus"
+import { Task } from "./Task"
+
+export class IdeTask 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 IdeTask.IDE_TASK_TYPE
+  }
+
+  static IDE_TASK_TYPE = "ide"
+}

package/src/courseFormat/tasks/NumberTask.ts

@@ -0,0 +1,17 @@
+import { CheckStatus } from "../CheckStatus"
+import { AnswerTask } from "./AnswerTask"
+
+export class NumberTask extends AnswerTask {
+  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 NumberTask.NUMBER_TASK_TYPE
+  }
+
+  static NUMBER_TASK_TYPE = "number"
+}

package/src/courseFormat/tasks/OutputTask.ts

@@ -0,0 +1,21 @@
+import { CheckStatus } from "../CheckStatus"
+import { OutputTaskBase } from "./OutputTaskBase"
+
+export class OutputTask extends OutputTaskBase {
+  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 OutputTask.OUTPUT_TASK_TYPE
+  }
+
+  get isToSubmitToRemote(): boolean {
+    return this.checkStatus !== CheckStatus.Unchecked
+  }
+
+  static OUTPUT_TASK_TYPE = "output"
+}

package/src/courseFormat/tasks/OutputTaskBase.ts

@@ -0,0 +1,23 @@
+import { CheckStatus } from "../CheckStatus"
+import { Task } from "./Task"
+
+export abstract class OutputTaskBase extends Task {
+  inputFileName = OutputTaskBase.INPUT_PATTERN_NAME
+  outputFileName = OutputTaskBase.OUTPUT_PATTERN_NAME
+  latestOutputFileName = OutputTaskBase.LATEST_OUTPUT_PATTERN_NAME
+
+  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 supportSubmissions(): boolean {
+    return true
+  }
+
+  static OUTPUT_PATTERN_NAME = "output.txt"
+  static INPUT_PATTERN_NAME = "input.txt"
+  static LATEST_OUTPUT_PATTERN_NAME = "latest_output.txt"
+}

package/src/courseFormat/tasks/RemoteEduTask.ts

@@ -0,0 +1,18 @@
+import { CheckStatus } from "../CheckStatus"
+import { EduTask } from "./EduTask"
+
+export class RemoteEduTask extends EduTask {
+  checkProfile = ""
+
+  constructor()
+  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 RemoteEduTask.REMOTE_EDU_TASK_TYPE
+  }
+
+  static REMOTE_EDU_TASK_TYPE = "remote_edu"
+}

package/src/courseFormat/tasks/StringTask.ts

@@ -0,0 +1,17 @@
+import { CheckStatus } from "../CheckStatus"
+import { AnswerTask } from "./AnswerTask"
+
+export class StringTask extends AnswerTask {
+  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 StringTask.STRING_TASK_TYPE
+  }
+
+  static STRING_TASK_TYPE = "string"
+}

package/src/courseFormat/tasks/TableTask.ts

@@ -0,0 +1,51 @@
+import { CheckStatus } from "../CheckStatus"
+import { Task } from "./Task"
+import { logger } from "../loggerUtils"
+
+export class TableTask extends Task {
+  isMultipleChoice = false
+  rows: string[] = []
+  columns: string[] = []
+  selected: boolean[][] = []
+
+  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 TableTask.TABLE_TASK_TYPE
+  }
+
+  choose(rowIndex: number, columnIndex: number): void {
+    if (rowIndex < 0 || rowIndex >= this.rows.length || columnIndex < 0 || columnIndex >= this.columns.length) {
+      logger("TableTask").error("There was an attempt to choose a cell with invalid indices")
+      return
+    }
+    if (!this.isMultipleChoice) {
+      this.clearSelectedInRow(rowIndex)
+    }
+    this.selected[rowIndex][columnIndex] = !this.selected[rowIndex][columnIndex]
+  }
+
+  clearSelectedVariants(): void {
+    for (let rowIndex = 0; rowIndex < this.selected.length; rowIndex += 1) {
+      this.clearSelectedInRow(rowIndex)
+    }
+  }
+
+  private clearSelectedInRow(rowIndex: number): void {
+    this.selected[rowIndex] = this.selected[rowIndex].map(() => false)
+  }
+
+  createTable(rows: string[], columns: string[], isCheckbox = false): void {
+    this.rows = rows
+    this.columns = columns
+    this.isMultipleChoice = isCheckbox
+    this.selected = rows.map(() => columns.map(() => false))
+  }
+
+  static TABLE_TASK_TYPE = "table"
+}

package/src/courseFormat/tasks/Task.ts

@@ -0,0 +1,181 @@
+import { CheckFeedback } from "../CheckFeedback"
+import { CheckStatus } from "../CheckStatus"
+import { DescriptionFormat } from "../DescriptionFormat"
+import { ItemContainer } from "../ItemContainer"
+import type { Lesson } from "../Lesson"
+import { Course } from "../Course"
+import { TaskFile } from "../TaskFile"
+import { StudyItem } from "../StudyItem"
+import { logger } from "../loggerUtils"
+
+function getLessonModuleLazy(): { Lesson: typeof Lesson } {
+  // eslint-disable-next-line @typescript-eslint/no-var-requires
+  return require("../Lesson")
+}
+
+export abstract class Task extends StudyItem {
+  private _taskFiles: Map<string, TaskFile> = new Map()
+
+  get taskFiles(): Map<string, TaskFile> {
+    return this._taskFiles
+  }
+
+  set taskFiles(value: Map<string, TaskFile>) {
+    this._taskFiles = value
+  }
+
+  feedback?: CheckFeedback
+  descriptionText = ""
+  descriptionFormat: DescriptionFormat = DescriptionFormat.MD
+  feedbackLink?: string
+  solutionHidden?: boolean
+  record = -1
+  isUpToDate = true
+
+  protected checkStatus: CheckStatus = CheckStatus.Unchecked
+
+  get status(): CheckStatus {
+    return this.checkStatus
+  }
+
+  set status(status: CheckStatus) {
+    for (const taskFile of this._taskFiles.values()) {
+      for (const placeholder of taskFile.answerPlaceholders) {
+        placeholder.status = status
+      }
+    }
+    if (this.checkStatus !== status) {
+      this.feedback = undefined
+    }
+    this.checkStatus = status
+  }
+
+  get lesson(): Lesson {
+    const LessonClass = getLessonModuleLazy().Lesson
+    if (!(this.parent instanceof LessonClass)) {
+      throw new Error(`Lesson is null for task ${this.name}`)
+    }
+    return this.parent as Lesson
+  }
+
+  get isPluginTaskType(): boolean {
+    return true
+  }
+
+  get supportSubmissions(): boolean {
+    return false
+  }
+
+  get isToSubmitToRemote(): boolean {
+    return false
+  }
+
+  get isChangedOnFailed(): boolean {
+    return false
+  }
+
+  get course(): Course {
+    return this.lesson.course
+  }
+
+  get files(): TaskFile[] {
+    return this.getTaskFileValues()
+  }
+
+  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)
+    if (id !== undefined) this.id = id
+    if (position !== undefined) this.index = position
+    if (updateDate !== undefined) this.updateDate = updateDate
+    if (status !== undefined) this.checkStatus = status
+  }
+
+  override init(parentItem: ItemContainer, isRestarted: boolean): void {
+    this.parent = parentItem
+    for (const taskFile of this._taskFiles.values()) {
+      taskFile.initTaskFile(this, isRestarted)
+    }
+  }
+
+  getTaskFile(name: string): TaskFile | undefined {
+    return this._taskFiles.get(name)
+  }
+
+  addTaskFile(name: string, isVisible = true): TaskFile {
+    const taskFile = new TaskFile()
+    taskFile.task = this
+    taskFile.name = name
+    taskFile.isVisible = isVisible
+    this._taskFiles.set(name, taskFile)
+    return taskFile
+  }
+
+  addTaskFileInstance(taskFile: TaskFile): void {
+    taskFile.task = this
+    this._taskFiles.set(taskFile.name, taskFile)
+  }
+
+  addTaskFileAt(taskFile: TaskFile, position: number): void {
+    taskFile.task = this
+    if (position < 0 || position > this._taskFiles.size) {
+      throw new Error("IndexOutOfBounds")
+    }
+    const entries = Array.from(this._taskFiles.entries())
+    entries.splice(position, 0, [taskFile.name, taskFile])
+    this._taskFiles = new Map(entries)
+  }
+
+  setTaskFileValues(taskFiles: TaskFile[]): void {
+    this._taskFiles.clear()
+    for (const taskFile of taskFiles) {
+      this._taskFiles.set(taskFile.name, taskFile)
+    }
+  }
+
+  getTaskFileValues(): TaskFile[] {
+    return Array.from(this._taskFiles.values())
+  }
+
+  removeTaskFile(taskFile: string): TaskFile | undefined {
+    const value = this._taskFiles.get(taskFile)
+    this._taskFiles.delete(taskFile)
+    return value
+  }
+
+  taskFileIndex(taskFile: string): number | undefined {
+    const index = Array.from(this._taskFiles.keys()).indexOf(taskFile)
+    return index === -1 ? undefined : index
+  }
+
+  equals(other: Task): boolean {
+    if (this === other) return true
+    if (this.index !== other.index) return false
+    if (this.name !== other.name) return false
+    if (this._taskFiles !== other._taskFiles) return false
+    if (this.descriptionText !== other.descriptionText) return false
+    return this.descriptionFormat === other.descriptionFormat
+  }
+
+  hashCode(): number {
+    let result = hashString(this.name)
+    result = 31 * result + this.index
+    result = 31 * result + this._taskFiles.size
+    result = 31 * result + hashString(this.descriptionText)
+    result = 31 * result + hashString(this.descriptionFormat)
+    return result
+  }
+
+  static LOG = logger("Task")
+}
+
+function hashString(value: string): number {
+  let hash = 0
+  for (let i = 0; i < value.length; i += 1) {
+    hash = (hash << 5) - hash + value.charCodeAt(i)
+    hash |= 0
+  }
+  return hash
+}

package/src/courseFormat/tasks/TheoryTask.ts

@@ -0,0 +1,19 @@
+import { CheckStatus } from "../CheckStatus"
+import { Task } from "./Task"
+
+export class TheoryTask extends Task {
+  postSubmissionOnOpen = true
+
+  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 TheoryTask.THEORY_TASK_TYPE
+  }
+
+  static THEORY_TASK_TYPE = "theory"
+}

package/src/courseFormat/tasks/UnsupportedTask.ts

@@ -0,0 +1,17 @@
+import { CheckStatus } from "../CheckStatus"
+import { Task } from "./Task"
+
+export class UnsupportedTask 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 UnsupportedTask.UNSUPPORTED_TASK_TYPE
+  }
+
+  static UNSUPPORTED_TASK_TYPE = "unsupported"
+}

package/src/courseFormat/tasks/choice/ChoiceOption.ts

@@ -0,0 +1,37 @@
+import { ChoiceOptionStatus } from "./ChoiceOptionStatus"
+
+export class ChoiceOption {
+  text = ""
+  status: ChoiceOptionStatus = ChoiceOptionStatus.UNKNOWN
+
+  constructor()
+  constructor(text: string)
+  constructor(text: string, status: ChoiceOptionStatus)
+  constructor(text?: string, status?: ChoiceOptionStatus) {
+    if (text !== undefined) {
+      this.text = text
+    }
+    if (status !== undefined) {
+      this.status = status
+    }
+  }
+
+  equals(other: ChoiceOption): boolean {
+    return this.text === other.text && this.status === other.status
+  }
+
+  hashCode(): number {
+    let result = hashString(this.text)
+    result = 31 * result + hashString(this.status)
+    return result
+  }
+}
+
+function hashString(value: string): number {
+  let hash = 0
+  for (let i = 0; i < value.length; i += 1) {
+    hash = (hash << 5) - hash + value.charCodeAt(i)
+    hash |= 0
+  }
+  return hash
+}

package/src/courseFormat/tasks/choice/ChoiceOptionStatus.ts

@@ -0,0 +1,5 @@
+export enum ChoiceOptionStatus {
+  CORRECT = "CORRECT",
+  INCORRECT = "INCORRECT",
+  UNKNOWN = "UNKNOWN",
+}

package/src/courseFormat/tasks/choice/ChoiceTask.ts

@@ -0,0 +1,57 @@
+import { CheckStatus } from "../../CheckStatus"
+import { message } from "../../uiMessages"
+import { Task } from "../Task"
+import { ChoiceOption } from "./ChoiceOption"
+
+export class ChoiceTask extends Task {
+  choiceOptions: ChoiceOption[] = []
+  isMultipleChoice = false
+  selectedVariants: number[] = []
+  messageCorrect: string = message("check.correct.solution")
+  messageIncorrect: string = message("check.incorrect.solution")
+  quizHeader?: string
+  canCheckLocally = true
+
+  constructor()
+  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 ChoiceTask.CHOICE_TASK_TYPE
+  }
+
+  get isPluginTaskType(): boolean {
+    return false
+  }
+
+  get isChangedOnFailed(): boolean {
+    return !this.canCheckLocally
+  }
+
+  get isToSubmitToRemote(): boolean {
+    return this.status !== CheckStatus.Unchecked
+  }
+
+  get presentableQuizHeader(): string {
+    if (this.quizHeader) return this.quizHeader
+    return this.isMultipleChoice
+      ? message("course.creator.create.choice.task.multiple.label")
+      : message("course.creator.create.choice.task.single.label")
+  }
+
+  addSelectedVariant(variant: number): void {
+    this.selectedVariants.push(variant)
+  }
+
+  removeSelectedVariant(variant: number): void {
+    this.selectedVariants = this.selectedVariants.filter((value) => value !== variant)
+  }
+
+  clearSelectedVariants(): void {
+    this.selectedVariants = []
+  }
+
+  static CHOICE_TASK_TYPE = "choice"
+}

package/src/courseFormat/tasks/matching/MatchingTask.ts

@@ -0,0 +1,19 @@
+import { CheckStatus } from "../../CheckStatus"
+import { SortingBasedTask } from "./SortingBasedTask"
+
+export class MatchingTask extends SortingBasedTask {
+  captions: string[] = []
+
+  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 MatchingTask.MATCHING_TASK_TYPE
+  }
+
+  static MATCHING_TASK_TYPE = "matching"
+}

package/src/courseFormat/tasks/matching/SortingBasedTask.ts

@@ -0,0 +1,59 @@
+import { CheckStatus } from "../../CheckStatus"
+import { logger } from "../../loggerUtils"
+import { Task } from "../Task"
+
+export abstract class SortingBasedTask extends Task {
+  private _options: string[] = []
+  ordering: number[] = []
+
+  get options(): string[] {
+    return this._options
+  }
+
+  set options(value: string[]) {
+    this.ordering = value.map((_, index) => index)
+    this._options = value
+  }
+
+  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)
+  }
+
+  getOrderedOptions(): string[] {
+    return this.options.map((_, index) => this.options[this.ordering[index]])
+  }
+
+  moveOptionUp(index: number): void {
+    const targetIndex = index - 1
+    if (targetIndex < 0) {
+      const message = "There was an attempt to move the option up out of bounds"
+      logger("SortingBasedTask").error(message)
+      throw new Error(message)
+    }
+    this.swapOptions(index, targetIndex)
+  }
+
+  moveOptionDown(index: number): void {
+    const targetIndex = index + 1
+    if (targetIndex === this.options.length) {
+      const message = "There was an attempt to move the option down out of bounds"
+      logger("SortingBasedTask").error(message)
+      throw new Error(message)
+    }
+    this.swapOptions(index, targetIndex)
+  }
+
+  swapOptions(firstColumnIndex: number, secondColumnIndex: number): void {
+    const firstOptionIndex = this.ordering[firstColumnIndex]
+    const secondOptionIndex = this.ordering[secondColumnIndex]
+    this.ordering[firstColumnIndex] = secondOptionIndex
+    this.ordering[secondColumnIndex] = firstOptionIndex
+  }
+
+  restoreInitialOrdering(): void {
+    this.ordering = this.options.map((_, index) => index)
+  }
+}

package/src/courseFormat/tasks/matching/SortingTask.ts

@@ -0,0 +1,17 @@
+import { CheckStatus } from "../../CheckStatus"
+import { SortingBasedTask } from "./SortingBasedTask"
+
+export class SortingTask extends SortingBasedTask {
+  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 SortingTask.SORTING_TASK_TYPE
+  }
+
+  static SORTING_TASK_TYPE = "sorting"
+}

package/src/courseFormat/uiMessages.ts

@@ -0,0 +1,12 @@
+const FORMAT_BUNDLE = "messages.EduFormatBundle"
+
+export function message(key: string, ...params: Array<string | number>): string {
+  if (params.length === 0) {
+    return key
+  }
+  return params.reduce((result: string, param, index) => {
+    return result.replace(new RegExp(`\\{${index}\\}`, "g"), String(param))
+  }, key)
+}
+
+export { FORMAT_BUNDLE }