@ueu/ueu-canvas 0.0.2 → 0.0.3

package/src/content/getContentFuncs.ts

@@ -1,30 +0,0 @@
-import {CONTENT_KINDS, getContentKindFromUrl} from "@/content/determineContent";
-import assert from "assert";
-import {BaseContentItem} from "@/content/BaseContentItem";
-
-
-
-function getAllLinks(body:string): string[] {
-    const el = bodyAsElement(body);
-    const anchors = el.querySelectorAll('a');
-    const urls: string[] = [];
-    for (const link of anchors) urls.push(link.href);
-    return urls;
-
-}
-
-
-function bodyAsElement(body: string) {
-    const el = document.createElement('div');
-    el.innerHTML = body;
-    return el;
-}
-export function getFileLinks(body: string, courseId: number) {
-    return getAllLinks(body).filter(a => a.match(/instructure\.com.*files\/\d+/i)).map(a => a.split('?')[0]);
-}
-
-export function getExternalLinks(body: string, courseId: number) {
-    // Correct regex to exclude unity.instructure.com links properly
-    return getAllLinks(body).filter(a => !a.match(/:\/\/unity\.instructure\.com\//i))
-
-}

package/src/content/openThisContentInTarget.ts

@@ -1,38 +0,0 @@
-import {Course} from "@/course/Course";
-import {getContentItemFromUrl} from "@/content/determineContent";
-import {BaseContentItem} from "@/content/BaseContentItem";
-
-function getIdOrCourse(courseOrId: number | Course) {
-    if (typeof courseOrId === 'object') return courseOrId.id;
-    return courseOrId;
-}
-
-export default async function openThisContentInTarget(
-    currentCourse: Course | number,
-    target: Course | Course[] | number | number[]
-) {
-    if (!window) return;
-
-    const currentCourseId = getIdOrCourse(currentCourse);
-    const targetCourseIds = Array.isArray(target) ? target.map(getIdOrCourse) : [getIdOrCourse(target)];
-
-    
-    const currentContentItem: BaseContentItem | null = await getContentItemFromUrl(document.documentURI);
-    const targetInfos = targetCourseIds.map((targetCourseId) => {
-        return {
-            courseId: targetCourseId,
-            contentItemPromise: currentContentItem?.getMeInAnotherCourse(targetCourseId)
-        }
-    });
-
-    for (const {courseId, contentItemPromise} of targetInfos) {
-        const targetContentItem = await contentItemPromise;
-        if (targetContentItem) {
-            window.open(targetContentItem.htmlContentUrl);
-        } else {
-            const url = document.URL.replace(currentCourseId.toString(), courseId.toString())
-            window.open(url);
-        }
-    }
-}
-

package/src/content/pages/Page.ts

@@ -1,35 +0,0 @@
-import {BaseContentItem} from "@/content/BaseContentItem";
-import {ICanvasCallConfig} from "@/canvasUtils";
-import PageKind from "@/content/pages/PageKind";
-import {IPageData} from "@/content/pages/types";
-
-
-export class Page extends BaseContentItem {
-    static kindInfo = PageKind
-    static idProperty = 'page_id';
-    static nameProperty = 'title';
-    static bodyProperty = 'body';
-    static contentUrlTemplate = "/api/v1/courses/{course_id}/pages/{content_id}";
-    static allContentUrlTemplate = "/api/v1/courses/{course_id}/pages";
-
-    constructor(canvasData: IPageData, courseId: number) {
-        super(canvasData, courseId);
-    }
-
-    get body(): string {
-        return this.canvasData[this.bodyKey];
-    }
-
-    async updateContent(text?: string | null, name?: string | null, config?: ICanvasCallConfig) {
-        const data: Record<string, any> = {};
-        if (text) {
-            this.canvasData[this.bodyKey] = text;
-            data['wiki_page[body]'] = text;
-        }
-        if (name) {
-            this.canvasData[this.nameKey] = name;
-            data[this.nameKey] = name;
-        }
-        return this.saveData(data, config);
-    }
-}

package/src/content/pages/PageKind.ts

@@ -1,39 +0,0 @@
-import {fetchJson} from "@/fetch/fetchJson";
-import {getPagedDataGenerator} from "@/fetch/getPagedDataGenerator";
-import {IPageData} from "@/content/pages/types";
-import {
-    ContentKind,
-    contentUrlFuncs,
-    courseContentUrlFunc,
-    postContentFunc,
-    putContentFunc
-} from "@/content/ContentKind";
-
-export const PageUrlFuncs = contentUrlFuncs('pages')
-export type GetPageOptions = Record<string, any>;
-export type SavePageOptions = Record<string, any>;
-
-
-const getStringApiUrl = courseContentUrlFunc<string>(`/api/v1/courses/{courseId}/pages/{contentId}`)
-
-const PageKind: Required<
-    ContentKind<IPageData, GetPageOptions, SavePageOptions>
->= {
-    ...PageUrlFuncs,
-    dataIsThisKind: (data): data is IPageData => {
-        return 'page_id' in data
-    },
-    getName: page => page.title,
-    getBody: page => page.body,
-    getId: page => page.id,
-    get: (id, courseId, config) =>
-        fetchJson(PageUrlFuncs.getApiUrl(courseId, id), config),
-    getByString: (courseId, contentId, config) =>
-        fetchJson<IPageData|{message: string}>(getStringApiUrl(courseId, contentId), config),
-    dataGenerator: (courseId, config = { queryParams: {include: ['body']}}) =>
-        getPagedDataGenerator(PageUrlFuncs.getAllApiUrl(courseId), config),
-    put: putContentFunc(PageUrlFuncs.getApiUrl),
-    post: postContentFunc(PageUrlFuncs.getAllApiUrl),
-}
-
-export default PageKind;

package/src/content/pages/__tests__/PageKind.test.ts

@@ -1,86 +0,0 @@
-
-import {fetchJson} from "@/fetch/fetchJson";
-import {getPagedDataGenerator} from "@/fetch/getPagedDataGenerator";
-import {IPageData} from "@/content/pages/types";
-import {mockDiscussionData, mockPageData} from "@/content/__mocks__/mockContentData";
-import PageKind, {GetPageOptions, SavePageOptions} from "@/content/pages/PageKind";
-
-// Mock dependencies
-jest.mock("@/fetch/fetchJson");
-jest.mock("@/fetch/getPagedDataGenerator");
-
-describe("PageKind", () => {
-    const courseId = 123;
-    const pageId = 456;
-    const contentId = "sample-page";
-    const mockConfig: GetPageOptions | SavePageOptions = {};
-
-    const localMockPageData: IPageData = {
-        ...mockPageData,
-        id: pageId,
-        title: "Sample Page",
-        body: "This is a sample page.",
-        page_id: pageId,
-    };
-
-    beforeEach(() => {
-        jest.clearAllMocks();
-    });
-
-    it("should return true for dataIsThisKind when data contains page_id", () => {
-        expect(PageKind.dataIsThisKind(localMockPageData)).toBe(true);
-    });
-
-    it("should return false for dataIsThisKind when data does not contain page_id", () => {
-        const data = { name: "Sample Page", body: "No ID here", ...mockDiscussionData };
-        expect(PageKind.dataIsThisKind(data)).toBe(false);
-    });
-
-    it("should return the correct name of the page", () => {
-        expect(PageKind.getName(localMockPageData)).toBe(localMockPageData.title);
-    });
-
-    it("should return the correct body of the page", () => {
-        expect(PageKind.getBody(localMockPageData)).toBe(localMockPageData.body);
-    });
-
-    it("should return the correct id of the page", () => {
-        expect(PageKind.getId(localMockPageData)).toBe(localMockPageData.id);
-    });
-
-    it("should fetch page data using get function", async () => {
-        (fetchJson as jest.Mock).mockResolvedValue(localMockPageData);
-
-        const result = await PageKind.get(pageId, courseId, mockConfig);
-
-        expect(fetchJson).toHaveBeenCalledWith(PageKind.getApiUrl(courseId, pageId), mockConfig);
-        expect(result).toBe(localMockPageData);
-    });
-
-    it("should fetch page data using getByString function", async () => {
-        (fetchJson as jest.Mock).mockResolvedValue(localMockPageData);
-
-        const result = await PageKind.getByString(courseId, contentId, mockConfig);
-        expect(result).toBe(localMockPageData);
-    });
-
-    it("should generate paged data using dataGenerator function", async () => {
-        const mockGenerator = jest.fn();
-        (getPagedDataGenerator as jest.Mock).mockReturnValue(mockGenerator);
-
-        const result = PageKind.dataGenerator(courseId, mockConfig);
-
-        expect(getPagedDataGenerator).toHaveBeenCalledWith(PageKind.getAllApiUrl(courseId), mockConfig);
-        expect(result).toBe(mockGenerator);
-    });
-
-    it("should call putContentFunc when put is called", async () => {
-        const mockPutResponse = { success: true };
-        (fetchJson as jest.Mock).mockResolvedValue(mockPutResponse);
-
-        const result = await PageKind.put(courseId, pageId, localMockPageData);
-
-
-        expect(result).toBe(mockPutResponse);
-    });
-});

package/src/content/pages/__tests__/learningMaterialsForModule.ts

@@ -1,57 +0,0 @@
-import PageKind from "@canvas/content/pages/PageKind";
-import {afterEach, beforeEach} from "@jest/globals";
-import mockModuleData, {mockModuleItemData} from "@canvas/course/__mocks__/mockModuleData";
-import mock = jest.mock;
-import learningMaterialsForModule from "../learningMaterialsForModule";
-import {renderAsyncGen} from "@canvas/canvasUtils";
-import {IModuleData} from "@canvas/canvasDataDefs";
-
-jest.mock('@canvas/content/pages/PageKind', () => ({
-    get: jest.fn(),
-}));
-
-const pageGet = PageKind.get as jest.Mock;
-
-describe('getLearningMaterialsWithModule', () => {
-    beforeEach(() => {
-        jest.clearAllMocks();
-    });
-    afterEach(() => {
-        jest.clearAllMocks();
-    });
-
-    it('Gets learning materials from course pages', async () => {
-        const courseId = 123;
-        const mockModule =
-            {
-                ...mockModuleData,
-                id: 1,
-                items: [{ title: 'Week 1 Learning Materials', content_id: 101}]
-            };
-
-        pageGet.mockResolvedValueOnce({id: 101, content: 'Learning materials content'});
-
-        const result = await renderAsyncGen(learningMaterialsForModule(courseId, mockModule as IModuleData));
-
-        expect(pageGet).toHaveBeenCalledWith(courseId, 101);
-        expect(result).toEqual( [{
-            item: {content_id: 101, title: 'Week 1 Learning Materials'},
-            page: {id: 101, content: 'Learning materials content'}
-    }] );
-    });
-    it('Skips non learning materials', async () => {
-        const courseId = 123;
-        const mockModule =
-            {
-                ...mockModuleData,
-                id: 1,
-                items: [{...mockModuleItemData, title: 'Week 1 Overview', content_id: 101}]
-                    .map(a => ({...mockModuleItemData, ...a})),
-            };
-
-
-        const result = await  renderAsyncGen(learningMaterialsForModule(courseId, mockModule));
-
-        expect(result).toEqual([]);
-    });
-});

package/src/content/pages/index.ts

@@ -1,12 +0,0 @@
-import learningMaterialsForModule from "./learningMaterialsForModule";
-import {Page} from "./Page";
-import PageKind from "./PageKind";
-import * as pageTypes from './types';
-
-export default {
-    learningMaterialsForModule,
-    Page,
-    PageKind,
-    ...pageTypes,
-
-}

package/src/content/pages/learningMaterialsForModule.ts

@@ -1,16 +0,0 @@
-import {IModuleData} from "@canvas/canvasDataDefs";
-import PageKind from "@canvas/content/pages/PageKind";
-
-
-export async function* learningMaterialsForModule(courseId: number, module: IModuleData) {
-
-    const lmItems = module.items.filter(a => a.title.match(/learning materials/i))
-    for await(const item of lmItems) {
-        const page = await PageKind.get(courseId, item.content_id)
-        yield { item, page  }
-    }
-}
-
-export default learningMaterialsForModule;
-
-

package/src/content/pages/types.ts

@@ -1,11 +0,0 @@
-import {CanvasData} from "@/canvasDataDefs";
-
-export interface IPageData extends CanvasData {
-    page_id: number,
-    url: string,
-    title: string,
-    body: string,
-    updated_at: string,
-    created_at: string,
-    front_page: boolean,
-}

package/src/content/quizzes/Quiz.ts

@@ -1,25 +0,0 @@
-import {BaseContentItem} from "@/content/BaseContentItem";
-import {fetchJson} from "@/fetch/fetchJson";
-import {formDataify} from "@/canvasUtils";
-
-
-export class Quiz extends BaseContentItem {
-    static nameProperty = 'title';
-    static bodyProperty = 'description';
-    static contentUrlTemplate = "/api/v1/courses/{course_id}/quizzes/{content_id}";
-    static allContentUrlTemplate = "/api/v1/courses/{course_id}/quizzes";
-
-    async setDueAt(date: Date): Promise<Record<string, any>> {
-        const url = `/api/v1/courses/${this.courseId}/quizzes/${this.id}`;
-        return fetchJson(url, {
-            fetchInit: {
-                method: 'PUT',
-                body: formDataify({
-                    quiz: {
-                        due_at: date
-                    }
-                })
-            }
-        })
-    }
-}

package/src/content/quizzes/QuizKind.ts

@@ -1,23 +0,0 @@
-import {ICanvasCallConfig} from "@/canvasUtils";
-import {fetchJson} from "@/fetch/fetchJson";
-import {getPagedDataGenerator} from "@/fetch/getPagedDataGenerator";
-
-import {GetQuizOptions, IQuizData, SaveQuizOptions} from "@/content/quizzes/types";
-import {ContentKind, contentUrlFuncs, putContentFunc} from "@/content/ContentKind";
-
-export const quizUrlFuncs = contentUrlFuncs('quizzes');
-const QuizKind: ContentKind<IQuizData, GetQuizOptions, SaveQuizOptions> = {
-    getId: (data) => data.id,
-    getName: (data) => data.title,
-    dataIsThisKind: (data): data is IQuizData => 'quiz_type' in data,
-    getBody: (data) => data.description,
-    async get(courseId: number, contentId: number, config?: ICanvasCallConfig<Record<string, any>>) {
-        const data = await fetchJson(quizUrlFuncs.getApiUrl(courseId, contentId), config) as IQuizData;
-        return data;
-    },
-    ...quizUrlFuncs,
-    dataGenerator: (courseId, config) => getPagedDataGenerator<IQuizData>(quizUrlFuncs.getAllApiUrl(courseId), config),
-    put: putContentFunc<SaveQuizOptions, IQuizData>(quizUrlFuncs.getApiUrl),
-}
-
-export default QuizKind;

package/src/content/quizzes/__tests__/QuizKind.test.ts

@@ -1,30 +0,0 @@
-import {mockQuizData} from "@/content/__mocks__/mockContentData";
-import QuizKind, {quizUrlFuncs} from "@/content/quizzes/QuizKind";
-import {getDataTests, kindUrlTests} from "@/content/__testingUtils__/utils";
-
-jest.mock('@/fetch/fetchJson')
-jest.mock('@/fetch/getPagedDataGenerator')
-describe('QuizKind', () => {
-    it('getId works', () => expect(QuizKind.getId({...mockQuizData, id: 100})).toEqual(100))
-    it('getName works', () => expect(QuizKind.getName({
-        ...mockQuizData,
-        title: "Quiz"
-    })).toEqual('Quiz'))
-    it('getBody works', () => expect(QuizKind.getBody({
-        ...mockQuizData,
-        description: "<p>Instructions</p>"
-    })).toEqual("<p>Instructions</p>"))
-
-    describe('get Data Tests', getDataTests(QuizKind, [
-        {...mockQuizData, id: 1},
-    ], { name: "x" }));
-
-})
-
-describe('QuizUrlFuncs', kindUrlTests(quizUrlFuncs,
-    1, 3,
-    '/api/v1/courses/1/quizzes/3',
-    '/courses/1/quizzes/3',
-    '/api/v1/courses/1/quizzes'
-))
-

package/src/content/quizzes/index.ts

@@ -1,3 +0,0 @@
-import {Quiz} from "@canvas/content/quizzes/Quiz";
-import QuizKind from "@canvas/content/quizzes/QuizKind";
-

package/src/content/quizzes/types.ts

@@ -1,101 +0,0 @@
-export interface IQuizData {
-    // the ID of the quiz
-    "id": number
-    // the title of the quiz
-    "title": string,
-    // the HTTP/HTTPS URL to the quiz
-    "html_url": string,
-    // a url suitable for loading the quiz in a mobile webview.  it will persist
-    // the headless session and, for quizzes in public courses, will force the user
-    // to login
-    "mobile_url": string,
-    // A url that can be visited in the browser with a POST request to preview a
-    // quiz as the teacher. Only present when the user may grade
-    "preview_url": string,
-    // the description of the quiz
-    "description": string,
-    // type of quiz possible values: 'practice_quiz', 'assignment', 'graded_survey',
-    // 'survey'
-    "quiz_type": "assignment" | 'practice_quiz' | 'graded_survey' | 'survey',
-    // the ID of the quiz's assignment group:
-    "assignment_group_id": number,
-    // quiz time limit in minutes
-    "time_limit"?: number,
-    // shuffle answers for students?
-    "shuffle_answers": boolean,
-    // let students see their quiz responses? possible values: null, 'always',
-    // 'until_after_last_attempt'
-    "hide_results": null | "always" | "until_after_last_attempt",
-    // show which answers were correct when results are shown? only valid if
-    // hide_results=null
-    "show_correct_answers"?: boolean,
-    // restrict the show_correct_answers option above to apply only to the last
-    // submitted attempt of a quiz that allows multiple attempts. only valid if
-    // show_correct_answers=true and allowed_attempts > 1
-    "show_correct_answers_last_attempt"?: boolean,
-    // when should the correct answers be visible by students? only valid if
-    // show_correct_answers=true
-    "show_correct_answers_at"?: string,
-    // prevent the students from seeing correct answers after the specified date has
-    // passed. only valid if show_correct_answers=true
-    "hide_correct_answers_at"?: string,
-    // prevent the students from seeing their results more than once (right after
-    // they submit the quiz)
-    "one_time_results": boolean,
-    // which quiz score to keep (only if allowed_attempts != 1) possible values:
-    // 'keep_highest', 'keep_latest'
-    "scoring_policy"?: "keep_highest" | "keep_latest",
-    // how many times a student can take the quiz -1 = unlimited attempts
-    "allowed_attempts": number,
-    // show one question at a time?
-    "one_question_at_a_time": boolean,
-    // the number of questions in the quiz
-    "question_count": number,
-    // The total point value given to the quiz
-    "points_possible": number,
-    // lock questions after answering? only valid if one_question_at_a_time=true
-    "cant_go_back"?: boolean,
-    // access code to restrict quiz access
-    "access_code"?: string,
-    // IP address or range that quiz access is limited to
-    "ip_filter"?: string,
-    // when the quiz is due
-    "due_at"?: string,
-    // when to lock the quiz
-    "lock_at"?: string | null,
-    // when to unlock the quiz
-    "unlock_at"?: string | null,
-    // whether the quiz has a published or unpublished draft state.
-    "published": boolean,
-    // Whether the assignment's 'published' state can be changed to false. Will be
-    // false if there are student submissions for the quiz.
-    "unpublishable": boolean,
-    // Whether or not this is locked for the user.
-    "locked_for_user": boolean,
-    // (Optional) Information for the user about the lock. Present when
-    // locked_for_user is true.
-    "lock_info"?: LockInfo | null,
-    // (Optional) An explanation of why this is locked for the user. Present when
-    // locked_for_user is true.
-    "lock_explanation"?: string,
-    // Link to Speed Grader for this quiz. Will not be present if quiz is
-    // unpublished
-    "speedgrader_url": string,
-    // Link to endpoint to send extensions for this quiz.
-    "quiz_extensions_url": string,
-    // Permissions the user has for the quiz
-    "permissions"?: QuizPermissions | null,
-    // list of due dates for the quiz
-    "all_dates": null | string[],
-    // Current version number of the quiz
-    "version_number": number,
-    // List of question types in the quiz
-    "question_types": string[],
-    // Whether survey submissions will be kept anonymous (only applicable to
-    // 'graded_survey', 'survey' quiz types)
-    "anonymous_submissions"?: boolean
-}
-
-export type QuizPermissions = Record<string, any>
-export type SaveQuizOptions = Record<string, any>
-export type GetQuizOptions = Record<string, any>