@ueu/ueu-canvas 0.0.2

package/src/content/BaseContentItem.ts

@@ -0,0 +1,219 @@
+import {fetchJson} from "@canvas/fetch/fetchJson";
+import {IFile, uploadFile} from "@canvas/files";
+import {BaseCanvasObject} from "@canvas/baseCanvasObject";
+import {CanvasData} from "@canvas/canvasDataDefs";
+import assert from "assert";
+import {deepObjectMerge, formDataify, ICanvasCallConfig} from "@canvas/canvasUtils";
+import {getPagedData} from "@canvas/fetch/getPagedDataGenerator";
+//import {getResizedBlob} from "@/image";
+import getCourseIdFromUrl from "@canvas/course/getCourseIdFromUrl";
+import {ContentKind} from "@canvas/content/ContentKind";
+import {NotImplementedException} from "@canvas/NotImplementedException";
+
+
+
+export class BaseContentItem extends BaseCanvasObject<CanvasData> {
+    static bodyProperty: string;
+    static nameProperty: string = 'name';
+    kind: ContentKind<any, any, any>|undefined = undefined;
+
+    _courseId: number;
+
+    constructor(canvasData: CanvasData, courseId: number) {
+        super(canvasData);
+        this._courseId = courseId;
+    }
+
+    get htmlContentUrl() {
+        return `${this.contentUrlPath}`.replace('/api/v1/', '/');
+    }
+
+
+    static get contentUrlPart() {
+        assert(this.allContentUrlTemplate, "Not a content url template");
+        const urlTermMatch = /\/([\w_]+)$/.exec(this.allContentUrlTemplate);
+        if (!urlTermMatch) return null;
+        return urlTermMatch[1];
+
+    }
+
+    static async getAllInCourse<T extends BaseContentItem>(courseId: number, config: ICanvasCallConfig | null = null) {
+        const url = this.getAllUrl(courseId);
+        const data = await getPagedData(url, config);
+        return data.map(item => new this(item, courseId)) as T[];
+    }
+
+    static clearAddedContentTags(text: string) {
+        if(!text) return null;
+        let out = text.replace(/<\/?link[^>]*>/g, '');
+        out = out.replace(/<\/?script[^>]*>/g, '');
+        return out;
+    }
+
+    static async getFromUrl(url: string | null = null, courseId: number | null = null) {
+        if (url === null) {
+            url = document.documentURI;
+        }
+
+        url = url.replace(/\.com/, '.com/api/v1')
+        const data = await fetchJson(url);
+        if (!courseId) {
+            courseId = getCourseIdFromUrl(url)
+            if (!courseId) return null;
+        }
+        //If this is a collection of data, we can't process it as a Canvas Object
+        if (Array.isArray(data)) return null;
+        assert(!Array.isArray(data));
+        if (data) {
+            return new this(data, courseId);
+        }
+        return null;
+    }
+
+    static async getById<T extends BaseContentItem>(contentId: number, courseId: number) {
+        return new this(await this.getDataById<T>(contentId, courseId), courseId)
+    }
+
+
+    get bodyKey() {
+        return this.myClass.bodyProperty;
+    }
+
+    get body() {
+        if (!this.bodyKey) return null;
+        return this.myClass.clearAddedContentTags(this.canvasData[this.bodyKey]);
+    }
+
+    get dueAt() {
+        if (!this.canvasData.hasOwnProperty('due_at')) {
+            return null;
+        }
+        if (!this.canvasData.due_at) return null;
+        return new Date(this.canvasData.due_at);
+    }
+
+    async setDueAt(date: Date): Promise<Record<string, any>> {
+        throw new NotImplementedException();
+    }
+
+    async dueAtTimeDelta(timeDelta: number) {
+        if (!this.dueAt) return null;
+        const result = new Date(this.dueAt);
+        result.setDate(result.getDate() + timeDelta)
+
+        return await this.setDueAt(result);
+    }
+
+    get contentUrlPath() {
+        let url = (<typeof BaseContentItem>this.constructor).contentUrlTemplate;
+        assert(url);
+        url = url.replace('{course_id}', this.courseId.toString());
+        url = url.replace('{content_id}', this.id.toString());
+
+        return url;
+    }
+
+    get courseId() {
+        return this._courseId;
+    }
+
+    async updateContent(text?: string | null, name?: string | null, config?: ICanvasCallConfig) {
+        const data: Record<string, any> = {};
+        const constructor = <typeof BaseContentItem>this.constructor;
+        assert(constructor.bodyProperty);
+        assert(constructor.nameProperty);
+        const nameProp = constructor.nameProperty;
+        const bodyProp = constructor.bodyProperty;
+        if (text && bodyProp) {
+            this.canvasData[bodyProp] = text;
+            data[bodyProp] = text;
+        }
+
+        if (name && nameProp) {
+            this.canvasData[nameProp] = name;
+            data[nameProp] = name;
+        }
+
+        return this.saveData(data, config);
+    }
+
+    async getMeInAnotherCourse(targetCourseId: number) {
+        const ContentClass = this.constructor as typeof BaseContentItem
+        const targets = await ContentClass.getAllInCourse(
+            targetCourseId,
+            {queryParams: {search_term: this.name}}
+        )
+        return targets.find((target: BaseContentItem) => target.name == this.name);
+    }
+
+    getAllLinks(): string[] {
+        const el = this.bodyAsElement;
+        const anchors = el.querySelectorAll('a');
+        const urls: string[] = [];
+        for (const link of anchors) urls.push(link.href);
+        return urls;
+
+    }
+
+
+    get bodyAsElement() {
+        assert(this.body, "This content item has no body property")
+        const el = document.createElement('div');
+        el.innerHTML = this.body;
+        return el;
+    }
+
+    // async resizeBanner(maxWidth = 2000) {
+    //     const bannerImg = getBannerImage(this);
+    //     if (!bannerImg) throw new Error("No banner");
+    //     const fileData = await getFileDataFromUrl(bannerImg.src, this.courseId)
+    //     if (!fileData) throw new Error("File not found");
+    //     if (bannerImg.naturalWidth < maxWidth) return; //Dont resize image unless we're shrinking it
+    //     const resizedImageBlob = await getResizedBlob(bannerImg.src, maxWidth);
+    //     const fileName = fileData.filename;
+    //     const fileUploadUrl = `/api/v1/courses/${this.courseId}/files`
+    //     assert(resizedImageBlob);
+    //     const file = new File([resizedImageBlob], fileName)
+    //     return await uploadFile(file, fileData.folder_id, fileUploadUrl);
+    // }
+}
+
+async function getFileDataFromUrl(url: string, courseId: number) {
+    const match = /.*\/files\/(\d+)/.exec(url);
+    if (!match) return null;
+    if (match) {
+        const fileId = parseInt(match[1]);
+        return await getFileData(fileId, courseId);
+    }
+}
+
+export function getBannerImage(overviewPage: BaseContentItem) {
+    const pageBody = document.createElement('html');
+    if (!overviewPage.body) throw new Error(`Content item ${overviewPage.name} has no html body`)
+    pageBody.innerHTML = overviewPage.body;
+    return pageBody.querySelector<HTMLImageElement>('.cbt-banner-image img');
+}
+
+async function getFileData(fileId: number, courseId: number) {
+    const url = `/api/v1/courses/${courseId}/files/${fileId}`
+    return await fetchJson(url) as IFile;
+}
+
+export function putContentConfig<T extends Record<string, any>>(data: T, config?: ICanvasCallConfig) {
+    return deepObjectMerge(config, {
+        fetchInit: {
+            method: 'PUT',
+            body: formDataify(data)
+        }
+    }, true);
+}
+export function postContentConfig<T extends Record<string, any>>(data: T, config?: ICanvasCallConfig) {
+    return deepObjectMerge(config, {
+        fetchInit: {
+            method: 'POST',
+            body: formDataify(data)
+        }
+    }, true);
+}
+
+

package/src/content/ContentKind.ts

@@ -0,0 +1,85 @@
+import {ICanvasCallConfig, IQueryParams} from "@/canvasUtils";
+import {CanvasData} from "@/canvasDataDefs";
+import {ContentData} from "@/content/types";
+import {fetchJson} from "@/fetch/fetchJson";
+import {postContentConfig, putContentConfig} from "@/content/BaseContentItem";
+
+
+export type ContentKind<
+    DataType extends ContentData,
+    GetQueryOptions extends IQueryParams = Record<string, any>,
+    PutDataType extends CanvasData = DataType,
+    PostDataType extends CanvasData = PutDataType,
+    IdType = number,
+> = {
+    getId: (data: DataType) => IdType,
+    dataIsThisKind: (data: Record<string, any>) => data is DataType,
+    getName: (data: DataType) => string,
+    getBody: (data: DataType) => string | undefined,
+    get: (courseId: number, contentId: number, config?: ICanvasCallConfig<GetQueryOptions>) => Promise<DataType>
+    getByString?: (courseId: number, contentId: string, config?: ICanvasCallConfig<GetQueryOptions>) => Promise<DataType|{ message: string}>
+    dataGenerator: (courseId: number, config?: ICanvasCallConfig<GetQueryOptions>) => AsyncGenerator<DataType>
+    put: (courseId: number, contentId: number, data: PutDataType) => Promise<DataType>,
+    post?: (courseId: number, data: PostDataType) => Promise<DataType>,
+} & ReturnType<typeof contentUrlFuncs>
+
+export function contentUrlFuncs(contentUrlPart: string) {
+
+    const urlRegex = new RegExp(`courses\/(\\d+)\/${contentUrlPart}/(\\d+)`, 'i');
+
+    const getApiUrl = courseContentUrlFunc(`/api/v1/courses/{courseId}/${contentUrlPart}/{contentId}`);
+    const getAllApiUrl = (courseId: number) => `/api/v1/courses/${courseId}/${contentUrlPart}`;
+    const getHtmlUrl = courseContentUrlFunc(`/courses/{courseId}/${contentUrlPart}/{contentId}`);
+
+    function getCourseAndContentIdFromUrl(url: string) {
+        const [full, courseId, contentId] = url.match(urlRegex) ?? [undefined, undefined, undefined];
+        return [courseId, contentId].map(a => a ? parseInt(a) : undefined);
+    }
+
+    const isValidUrl = (url?: string) => typeof url === 'string' && typeof getCourseAndContentIdFromUrl(url)[0] !== 'undefined';
+    return {
+        contentUrlPart,
+        getApiUrl,
+        getAllApiUrl,
+        getHtmlUrl,
+        getCourseAndContentIdFromUrl,
+        isValidUrl,
+    }
+}
+
+export function courseContentUrlFunc<T extends number | string = number>(url: string) {
+    return (courseId: number, contentId: T) => url
+        .replaceAll('{courseId}', courseId.toString())
+        .replaceAll('{contentId}', contentId.toString())
+}
+
+export function putContentFunc<
+    PutOptionsType extends Record<string, any>,
+    ResponseDataType extends Record<string, any>
+>(getApiUrl: (courseId: number, contentId: number) => string) {
+    return async function (
+        courseId: number,
+        contentId: number,
+        content: PutOptionsType,
+        config?: ICanvasCallConfig
+    ) {
+        const url = getApiUrl(courseId, contentId);
+        return await fetchJson<ResponseDataType>(url, putContentConfig(content, config))
+    }
+}
+
+
+export function postContentFunc<
+    PostOptionsType extends Record<string, any>,
+    ResponseDataType extends Record<string, any>
+>(getApiUrl: (courseId: number) => string) {
+    return async function (
+        courseId: number,
+        content: PostOptionsType,
+        config?: ICanvasCallConfig
+    ) {
+        const url = getApiUrl(courseId);
+        return await fetchJson<ResponseDataType>(url, postContentConfig(content, config))
+    }
+}
+

package/src/content/__mocks__/determineContent.ts

@@ -0,0 +1,27 @@
+import {mockAssignmentData} from "@/content/__mocks__/mockContentData";
+import {mockCourseData} from "@/course/__mocks__/mockCourseData";
+import {Assignment} from "@/content/assignments/Assignment";
+import {ContentData} from "@/content/types";
+import {ICanvasCallConfig} from "@/canvasUtils";
+
+import AssignmentKind from "@/content/assignments/AssignmentKind";
+
+export const getContentClassFromUrl = jest.fn((url: string | null = null) => {
+    return Assignment;
+});
+
+export const getContentItemFromUrl = jest.fn(
+    async (url: string | null = null)  =>
+        new Assignment(mockAssignmentData, mockCourseData.id))
+
+export function getContentKindFromUrl(url:string) {
+    return AssignmentKind;
+}
+
+export function getContentKindFromContent(contentData:ContentData) {
+    return AssignmentKind;
+}
+
+export async function getContentDataFromUrl(url:string, config:ICanvasCallConfig) {
+    return {...mockAssignmentData}
+}

package/src/content/__mocks__/mockAssignmentSubmission.ts

@@ -0,0 +1,37 @@
+import {IAssignmentSubmission} from "@canvas/content/types";
+
+const mockSubmission: IAssignmentSubmission = {
+  assignment_id: 23,
+  assignment: null,
+  course: null,
+  attempt: 1,
+  body: "There are three factors too...",
+  grade: "A-",
+  grade_matches_current_submission: true,
+  html_url: "https://example.com/courses/255/assignments/543/submissions/134",
+  preview_url: "https://example.com/courses/255/assignments/543/submissions/134?preview=1",
+  score: 13.5,
+  submission_comments: null,
+  submission_type: 'online_text_entry',
+  submitted_at: "2012-01-01T01:00:00Z",
+  url: null,
+  user_id: 134,
+  grader_id: 86,
+  graded_at: "2012-01-02T03:05:34Z",
+  user: null,
+  late: false,
+  assignment_visible: true,
+  excused: true,
+  missing: true,
+  late_policy_status: 'missing',
+  points_deducted: 12.3,
+  seconds_late: 300,
+  workflow_state: 'submitted',
+  extra_attempts: 10,
+  anonymous_id: "acJ4Q",
+  posted_at: "2020-01-02T11:10:30Z",
+  read_status: 'read',
+  redo_request: true
+};
+
+export default mockSubmission;

package/src/content/__mocks__/mockContentData.ts

@@ -0,0 +1,98 @@
+import {IQuizData} from "@/content/quizzes/types";
+import {IPageData} from "@/content/pages/types";
+import {IAssignmentData, IDiscussionData} from "@canvas/content/types";
+
+
+export const mockPageData: IPageData = {
+    created_at: "", front_page: false, updated_at: "",
+    page_id: 0,
+    url: 'http://localhost',
+    title: 'X',
+    body: '<div></div>'
+}
+
+
+//front docs
+export const mockQuizData: IQuizData = {
+    id: 0,
+    title: "",
+    html_url: "",
+    mobile_url: "",
+    preview_url: "",
+    description: "",
+    quiz_type: "assignment",
+    assignment_group_id: 0,
+    shuffle_answers: false,
+    hide_results: null,
+    one_time_results: false,
+    allowed_attempts: 0,
+    one_question_at_a_time: false,
+    question_count: 0,
+    points_possible: 0,
+    published: false,
+    unpublishable: false,
+    locked_for_user: false,
+    speedgrader_url: "",
+    quiz_extensions_url: "",
+    all_dates: null,
+    version_number: 0,
+    question_types: []
+}
+
+export const mockAssignmentData: IAssignmentData = {
+    anonymous_grading: false,
+    final_grader_id: 0,
+    grader_comments_visible_to_graders: false,
+    grader_count: 0,
+    grader_names_visible_to_final_grader: false,
+    graders_anonymous_to_graders: false,
+    hide_in_gradebook: false,
+    moderated_grading: false,
+    omit_from_final_grade: false,
+    allowed_extensions: [],
+    assignment_group_id: 0,
+    automatic_peer_reviews: false,
+    course_id: 0,
+    created_at: "",
+    description: "",
+    due_at: null,
+    due_date_required: false,
+    grade_group_students_individually: false,
+    has_overrides: false,
+    html_url: "",
+    integration_data: undefined,
+    intra_group_peer_reviews: false,
+    lock_at: null,
+    max_name_length: 0,
+    peer_reviews: false,
+    points_possible: 0,
+    position: 0,
+    submission_types: [],
+    submissions_download_url: "",
+    unlock_at: null,
+    updated_at: null,
+    id: 0, name: "", rubric: []
+}
+
+export const mockDiscussionData: IDiscussionData = {
+    allow_rating: false,
+    assignment_id: 1,
+    discussion_subentry_count: 0,
+    discussion_type: 'threaded',
+    locked: false,
+    locked_for_user: false,
+    only_graders_can_rate: false,
+    permissions: {},
+    pinned: false,
+    published: false,
+    read_state: 'unread',
+    sort_by_grading: false,
+    subscribed: false,
+    topic_children: [],
+    unread_count: 0,
+    user_can_see_posts: false,
+    user_name: "",
+    html_url: "", id: 0, last_reply_at: "", message: "", posted_at: "", require_initial_post: false, title: "",
+    delayed_post_at: ""
+
+}

package/src/content/__mocks__/openThisContentInTarget.ts

@@ -0,0 +1,2 @@
+const openThisContentInTarget = jest.fn();
+export default openThisContentInTarget;

package/src/content/__testingUtils__/utils.ts

@@ -0,0 +1,47 @@
+import {fetchJson} from "@/fetch/fetchJson";
+import {ICanvasCallConfig, renderAsyncGen} from "@/canvasUtils";
+import {getPagedDataGenerator} from "@/fetch/getPagedDataGenerator";
+import {mockAsyncGen} from "@/__mocks__/utils";
+import assert from "assert";
+import {putContentConfig} from "@/content/BaseContentItem";
+import {ContentKind, contentUrlFuncs} from "@/content/ContentKind";
+
+export function kindUrlTests(urlFuncs: ReturnType<typeof contentUrlFuncs>, courseId: number, contentId: number, apiUrl: string, htmlUrl: string, allUrl: string) {
+    return () => {
+        it("getApiUrl", () => expect(urlFuncs.getApiUrl(1, 3)).toEqual(apiUrl))
+        it("getHtmlUrl", () => expect(urlFuncs.getHtmlUrl(1, 3)).toEqual(htmlUrl))
+        it("getAllUrl", () => expect(urlFuncs.getAllApiUrl(1)).toEqual(allUrl))
+    }
+}
+
+export type KindDataType<T extends ContentKind<any, any, any>> = Awaited<ReturnType<T['get']>>;
+export type KindSaveType<T> = T extends ContentKind<infer A, infer B, infer C> ? B : never;
+
+export function getDataTests<Kind extends ContentKind<any, any, any>>(contentKind: Kind, mockDatas: KindDataType<Kind>[], mockSaveParams: KindSaveType<Kind>) {
+    type DataType = KindDataType<Kind>
+    type SaveType = KindSaveType<Kind>
+    return () => {
+        it('get works', async () => {
+            const content = {...mockDatas[0], id: 101};
+            (fetchJson as jest.Mock).mockResolvedValue(content);
+            const config: ICanvasCallConfig = {};
+            const received = await contentKind.get(0, 0, config);
+            expect(received).toEqual(content);
+            expect(fetchJson).toHaveBeenCalledWith(contentKind.getApiUrl(0, 0), config)
+        });
+        it('dataGenerator works', async () => {
+            (getPagedDataGenerator as jest.Mock).mockReturnValue(mockAsyncGen(mockDatas));
+            expect(await renderAsyncGen(contentKind.dataGenerator(1))).toEqual(mockDatas);
+        });
+        it('puts data', async() => {
+            (fetchJson as jest.Mock).mockResolvedValue(mockDatas[0])
+            if (!contentKind.put) {
+                expect(mockSaveParams).toBeUndefined();
+                return;
+            }
+            const result = await contentKind.put(1, 1, mockSaveParams);
+            expect(contentKind.dataIsThisKind(result))
+            expect(fetchJson as jest.Mock).toHaveBeenCalledWith(contentKind.getApiUrl(1, 1), putContentConfig(mockSaveParams, {}))
+        })
+    }
+}

package/src/content/__tests__/determineContent.test.ts

@@ -0,0 +1,101 @@
+import {
+    getContentClassFromUrl,
+    getContentItemFromUrl,
+    getContentKindFromContent,
+    getContentKindFromUrl
+} from "@/content/determineContent";
+import assert from "assert";
+import {
+    mockAssignmentData,
+    mockDiscussionData,
+    mockPageData,
+    mockQuizData
+} from "@/content/__mocks__/mockContentData";
+import {fetchJson} from "@/fetch/fetchJson";
+import {Quiz} from "@/content/quizzes/Quiz";
+import {Page} from "@/content/pages/Page";
+import {Discussion} from "@/content/discussions/Discussion";
+import {Assignment} from "@/content/assignments/Assignment";
+import AssignmentKind from "@/content/assignments/AssignmentKind";
+import QuizKind from "@/content/quizzes/QuizKind";
+import PageKind from "@/content/pages/PageKind";
+import DiscussionKind from "@/content/discussions/DiscussionKind";
+
+jest.mock('@/fetch/fetchJson', () => ({
+    fetchJson: jest.fn(),
+}))
+describe('getContentClassFromUrl', () => {
+    it('should return Assignment class when URL includes assignment', () => {
+        const url = 'https://example.com/assignments';
+        expect(getContentClassFromUrl(url)).toBe(Assignment);
+    });
+
+    it('should return Quiz class when URL includes quiz', () => {
+        const url = 'https://example.com/quizzes';
+        expect(getContentClassFromUrl(url)).toBe(Quiz);
+    });
+
+    it('should return Page class when URL includes page', () => {
+        const url = 'https://example.com/pages';
+        expect(getContentClassFromUrl(url)).toBe(Page);
+    });
+
+    it('should return Discussion class when URL includes discussion', () => {
+        const url = 'https://example.com/discussion_topics';
+        expect(getContentClassFromUrl(url)).toBe(Discussion);
+    });
+
+    it('should return null when URL does not match any class', () => {
+        const url = 'https://example.com/unknown';
+        expect(getContentClassFromUrl(url)).toBe(null);
+    });
+});
+
+describe('getContentItemFromUrl', () => {
+    let getContentApi: typeof import('../determineContent');
+    beforeEach(async () => {
+        getContentApi = await import('../determineContent');
+    })
+
+    it('should return null if getContentClassFromUrl returns null', async () => {
+        const result = await getContentItemFromUrl('https://example.com');
+        expect(result).toBe(null);
+    });
+
+    it('should call getAssignment from an assignment url', async () => {
+
+        const url = 'https://example.com/assignments';
+        const contentClass = getContentClassFromUrl(url);
+        assert(contentClass !== null)
+        const getAssignmentSpy = jest.spyOn(contentClass, 'getFromUrl');
+        (fetchJson as jest.Mock).mockResolvedValue(mockAssignmentData);
+
+        const assignment = await getContentItemFromUrl(url);
+        expect(getAssignmentSpy).toHaveBeenCalledWith(url);
+
+    });
+});
+
+
+describe('getContentKindFromUrl', () => {
+    it('Finds Assignments', () => {
+        expect(getContentKindFromUrl('/api/v1/courses/1/assignments/5')).toEqual(AssignmentKind)
+    })
+    it('Finds Discussions', () => {
+        expect(getContentKindFromUrl('/api/v1/courses/1/discussion_topics/5')).toEqual(DiscussionKind)
+    })
+    it('Finds Quizzes', () => {
+        expect(getContentKindFromUrl('/api/v1/courses/1/quizzes/5')).toEqual(QuizKind)
+    })
+    it('Finds Pages', () => {
+        expect(getContentKindFromUrl('/api/v1/courses/1/pages/5')).toEqual(PageKind)
+    })
+
+})
+
+describe('getContentKindFromContent', () => {
+    it('works for pages', () => expect(getContentKindFromContent(mockPageData)).toBe(PageKind))
+    it('works for discussions', () => expect(getContentKindFromContent(mockDiscussionData)).toBe(DiscussionKind))
+    it('works for assignments', () => expect(getContentKindFromContent(mockAssignmentData)).toBe(AssignmentKind))
+    it('works for quizzes', () => expect(getContentKindFromContent(mockQuizData)).toBe(QuizKind))
+})