@ueu/ueu-canvas 0.0.2 → 0.0.3

package/src/content/BaseContentItem.ts

@@ -1,219 +0,0 @@
-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

@@ -1,85 +0,0 @@
-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

@@ -1,27 +0,0 @@
-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

@@ -1,37 +0,0 @@
-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

@@ -1,98 +0,0 @@
-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

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

package/src/content/__testingUtils__/utils.ts

@@ -1,47 +0,0 @@
-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

@@ -1,101 +0,0 @@
-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))
-})