@ueu/ueu-canvas 0.0.2

package/src/course/migration/__tests__/migration.test.ts

@@ -0,0 +1,173 @@
+import fetchMock, {FetchMock} from "jest-fetch-mock";
+import {mockCourseData} from "../../__mocks__/mockCourseData";
+import {
+    copyToNewCourseGenerator,
+    courseMigrationGenerator, getMigration, migrationsForCourseGen,
+    IMigrationData,
+    IProgressData
+} from "../index";
+import {ICanvasCallConfig, range} from "@/canvasUtils";
+import {mockMigrationData} from "@/course/migration/__mocks__/mockMigrationData";
+
+import {Course} from "@/course/Course";
+import {config} from "dotenv";
+import {ICourseData} from "@/types";
+import {mockProgressData} from "@/course/__mocks__/mockProgressData";
+
+
+
+beforeEach(() => {
+    jest.clearAllMocks();
+});
+
+
+describe('Getting migrations', ()=> {
+
+    it('gets migrations from course', async ()=> {
+        const id = 123;
+        const config = { fetchInit: {}};
+        fetchMock.once(JSON.stringify([mockMigrationData, {...mockMigrationData, id: 321}]));
+        const generator = migrationsForCourseGen(id, config);
+        let result = await generator.next();
+        let migration = result.done? null : result.value;
+        expect(fetchMock).toHaveBeenCalledTimes(1);
+        expect(fetchMock).toHaveBeenCalledWith(`/api/v1/courses/${id}/content_migrations`, config.fetchInit);
+        expect(migration).toEqual(mockMigrationData);
+        result = await generator.next();
+        migration = result.done? null : result.value;
+        expect(migration?.id).toEqual(321);
+    })
+
+    it('gets a single mock by id', async ()=> {
+        const courseId = 123;
+        const migrationId = 321;
+        const config = { fetchInit: {} };
+        fetchMock.once(JSON.stringify(mockMigrationData));
+        const migration = await getMigration(courseId, migrationId, config);
+        expect(fetchMock).toHaveBeenCalledTimes(1);
+        expect(fetchMock).toHaveBeenCalledWith(
+            `/api/v1/courses/${courseId}/content_migrations/${migrationId}`,
+            config.fetchInit
+        );
+        expect(migration).toEqual(expect.objectContaining(mockMigrationData));
+    })
+
+    it('returns null if no migrations are found', async () => {
+        fetchMock.once('null');
+        const migration = await getMigration(1, 2, {});
+        expect(migration).toBeNull()
+
+    })
+})
+
+
+describe('Course migration', () => {
+    fetchMock.enableMocks();
+    afterEach(() => {
+        jest.clearAllMocks();
+    })
+    it('Yields values while still polling', async () => {
+
+        const workflowStates = [
+            ...[...range(0, 2)].map(_ => 'queued'),
+            ...[...range(0, 2)].map(_ => 'running'),
+            'completed'
+        ]
+
+        fetchMock.mockResponseOnce(JSON.stringify(<IMigrationData>{
+            ...mockMigrationData, workflow_state: 'queued'
+        }))
+        const migrationGenerator = courseMigrationGenerator(0, 1, 20);
+
+        for (const state of workflowStates) {
+            fetchMock.mockResponseOnce(JSON.stringify(<IProgressData>{
+                ...mockProgressData, workflow_state: state
+            }))
+        }
+        const workflowIterator = workflowStates.values();
+        for await (const progress of migrationGenerator) {
+            expect(progress?.workflow_state).toBe(workflowIterator.next().value)
+        }
+    })
+
+    it('Throws an error on a failed migration', async () => {
+        const workflowStates: IMigrationData["workflow_state"][] = [
+            'queued',
+            'running',
+            'failed'
+        ]
+
+        fetchMock.mockResponseOnce(JSON.stringify(<IMigrationData>{
+            ...mockMigrationData, workflow_state: 'queued'
+        }))
+        for (const state of workflowStates) {
+            fetchMock.mockResponseOnce(JSON.stringify(<IProgressData>{
+                ...mockProgressData, workflow_state: state
+            }))
+        }
+        const migrationGenerator = courseMigrationGenerator(0, 1, 0);
+
+        await expect(async () => {
+            for await (const progress of migrationGenerator) {
+                expect(progress?.id).toBe(mockProgressData.id)
+            }
+        }).rejects.toThrow(/Migration Error/)
+
+    })
+
+})
+
+describe('Course Copying', () => {
+    test('Copy course wholesale', async () => {
+        fetchMock.enableMocks();
+
+        const fetch = (global.fetch as FetchMock);
+        const courseName = 'Test course the testing course';
+        const courseCode = "TEST000";
+        const sourceCourseData = {
+            ...mockCourseData,
+            name: `DEV_${courseCode}: ${courseName}`,
+            course_code: `DEV_${courseCode}`
+        };
+        const sourceCourse = new Course(sourceCourseData);
+        const newCode = 'BP_TEST000';
+        const newName = `BP_TEST000: ${courseName}`;
+
+        const workflowStates = [
+            ...[...range(0, 2)].map(_ => 'queued'),
+            ...[...range(0, 2)].map(_ => 'running'),
+            'completed',
+
+        ]
+        const workflowIterator = workflowStates.values();
+        fetchMock.mockClear();
+        fetchMock.mockResponses(...[
+            sourceCourseData,
+            {...mockMigrationData, workflow_state: 'queued'},
+
+            ...workflowStates.map((state, i) => ({
+                ...mockProgressData,
+                workflow_state: state,
+                message: i.toString(),
+            } as IProgressData)),
+
+            {...sourceCourse.rawData, name: newName, course_code: newCode} as ICourseData,
+        ].map(value => JSON.stringify(value)))
+        const migrationGenerator = copyToNewCourseGenerator(sourceCourse, newCode, 20);
+
+        async function testCourseMigration() {
+            let result;
+            while (true) {
+                result = await migrationGenerator.next();
+                const {value} = workflowIterator.next();
+                if (result.done) return result.value;
+                expect(result.value.workflow_state).toBe(value)
+            }
+        }
+
+        const course: ICourseData = await testCourseMigration();
+        expect(course.name).toBe(newName);
+        expect(course.course_code).toBe(newCode);
+    })
+
+})

package/src/course/migration/__tests__/migrationCache.test.ts

@@ -0,0 +1,45 @@
+import {loadCachedCourseMigrations, cacheCourseMigrations, loadCachedMigrations} from "../migrationCache";
+import {mockMigrationData} from "@/course/migration/__mocks__/mockMigrationData";
+import {range} from "../../../canvasUtils";
+
+describe('Saving and loading migration states', () => {
+    beforeEach(() => {
+        localStorage.clear();
+    })
+    afterEach(() => {
+        localStorage.clear();
+    })
+    it('has base functions that save and load migration data', () => {
+        const migrations = loadCachedCourseMigrations(0);
+        expect(migrations).toHaveLength(0);
+
+        const cachedKeys:{[key:number] : number} = {};
+        for(const i of [...range(0, 5)]) {
+            const key = i * 2;
+            const migrationsToCache = [...range(1,i)].map( _ => mockMigrationData)
+            cacheCourseMigrations(i * 2,  migrationsToCache);
+            expect(Object.entries(loadCachedMigrations())).toHaveLength(i + 1)
+            cachedKeys[key] = i;
+            //Make sure all previous cached migrations have the same value going on.
+            for(const [key, value] of Object.entries(cachedKeys)) {
+                expect(loadCachedCourseMigrations(key)).toHaveLength(value);
+            }
+        }
+    })
+
+    it('adds new migrations to cached migration list', () => {
+        cacheCourseMigrations(1, [{...mockMigrationData, id: 1}])
+        expect(loadCachedCourseMigrations(1)).toHaveLength(1);
+        cacheCourseMigrations(1, [{...mockMigrationData, id: 2}])
+        expect(loadCachedCourseMigrations(1)).toHaveLength(2);
+     })
+
+    it('adds new migrations to cached migration list', () => {
+        cacheCourseMigrations(1, [{...mockMigrationData, id: 1, workflow_state: 'queued'}])
+        expect(loadCachedCourseMigrations(1)).toHaveLength(1);
+        cacheCourseMigrations(1, [{...mockMigrationData, id: 1, workflow_state: 'completed', cleanedUp: false}]);
+        expect(loadCachedCourseMigrations(1)).toHaveLength(1);
+     })
+
+
+})

package/src/course/migration/index.ts

@@ -0,0 +1,134 @@
+import {
+    deepObjectMerge,
+    formDataify,
+    ICanvasCallConfig
+} from "@/canvasUtils";
+import {createNewCourse, getCourseData} from "../toolbox";
+import {Course} from "../Course";
+
+import {getPagedDataGenerator} from "@/fetch/getPagedDataGenerator";
+
+import {fetchJson} from "@/fetch/fetchJson";
+import {GetCourseOptions} from "@/course/courseTypes";
+import {sleep} from "@/toolbox";
+export type WorkflowState = 'queued' | 'running' | 'completed' | 'failed';
+
+
+export interface IMigrationData {
+    migration_type: string;
+    migration_type_title: string;
+    pre_attachment: { upload_params: {}; upload_url: string; message: string };
+    attachment: { url: string };
+    finished_at: string;
+    user_id: number;
+    progress_url: string;
+    started_at: string;
+    workflow_state: WorkflowState;
+    id: number;
+    migration_issues_url: string
+}
+
+export interface IProgressData {
+    completion: number;
+    updated_at: string;
+    user_id: number;
+    context_type: string;
+    created_at: string;
+    context_id: number;
+    workflow_state: WorkflowState;
+    id: number;
+    tag: string;
+    message: string;
+    results: { id: string };
+    url: string
+}
+
+
+export function migrationsForCourseGen(courseId:number, config?:ICanvasCallConfig) {
+    const url = `/api/v1/courses/${courseId}/content_migrations`
+    return getPagedDataGenerator<IMigrationData>(url, config);
+
+}
+
+export async function getMigration(courseId:number,migrationId:number, config?:ICanvasCallConfig) {
+    try {
+        const data = await fetchJson(
+            `/api/v1/courses/${courseId}/content_migrations/${migrationId}`,
+            config,
+        );
+        return data as IMigrationData;
+
+    } catch (error) {
+        return null;
+    }
+}
+
+
+export async function* courseMigrationGenerator(
+    sourceCourseId: number,
+    destCourseId: number,
+    pollDelay: number = 500, //in ms
+    migrationConfig?: ICanvasCallConfig,
+    pollConfig?: ICanvasCallConfig
+) {
+
+    const migrationData = await startMigration(sourceCourseId, destCourseId, migrationConfig);
+    for await (const result of genCourseMigrationProgress(migrationData, pollDelay, pollConfig)) {
+        yield result;
+    }
+}
+
+export async function startMigration(sourceCourseId:number, destCourseId: number, config?:ICanvasCallConfig) {
+    const copyUrl = `/api/v1/courses/${destCourseId}/content_migrations`;
+    const migrationInit: RequestInit = {
+        method: 'POST',
+        body: formDataify({
+            migration_type: 'course_copy_importer',
+            settings: {
+                source_course_id: sourceCourseId,
+            }
+        })
+    }
+
+    config = deepObjectMerge(config, {fetchInit: migrationInit}, true);
+    return await fetchJson<IMigrationData>(copyUrl, config);
+}
+
+export async function* genCourseMigrationProgress(migration:IMigrationData, pollDelay: number = 500, pollConfig?: ICanvasCallConfig) {
+    const {progress_url: progressUrl} = migration;
+    while (true) {
+        await sleep(pollDelay);
+        const progress = await fetchJson<IProgressData>(progressUrl, pollConfig);
+        yield progress;
+        if (progress.workflow_state === 'completed') return
+        if (progress.workflow_state === 'failed') {
+            throw new Error(`Migration Error: ${progress.message}`);
+        }
+    }
+}
+
+export async function* copyToNewCourseGenerator(
+    sourceCourse: Course,
+    newCode: string,
+    pollDelay: number = 500,
+    newName?: string,
+    courseConfig?: ICanvasCallConfig<GetCourseOptions>,
+    migrationConfig?: ICanvasCallConfig,
+    pollConfig?: ICanvasCallConfig,
+    returnCourseConfig?: ICanvasCallConfig<GetCourseOptions>,
+) {
+    if (!newName && sourceCourse.parsedCourseCode) {
+        newName = sourceCourse.name.replace(sourceCourse.parsedCourseCode, newCode);
+    }
+
+    returnCourseConfig ??= courseConfig;
+    newName ??= sourceCourse.name + "_COPY";
+    const {destId} = await createNewCourse(newCode, sourceCourse.accountId, newName, courseConfig);
+    const migration = courseMigrationGenerator(sourceCourse.id, destId, pollDelay, migrationConfig, pollConfig);
+
+    for await (const progress of migration) {
+        yield progress;
+    }
+    return await getCourseData(destId, returnCourseConfig);
+
+}

package/src/course/migration/migrationCache.ts

@@ -0,0 +1,56 @@
+import {IMigrationData} from "./index";
+
+export type SavedMigration = IMigrationData & {
+    tracked?: boolean,
+    cleanedUp?: boolean,
+}
+
+export function loadCachedMigrations() {
+    if (!localStorage.getItem('migrations')) localStorage.setItem('migrations', '{}')
+    const migrationDataString = localStorage.getItem('migrations') as string;
+    const migrationDataList: Record<string, SavedMigration[]> = JSON.parse(migrationDataString) ?? {};
+    return migrationDataList;
+}
+
+export function loadCachedCourseMigrations(courseId: number | string) {
+    const key = courseId.toString();
+    return loadCachedMigrations()[key] ?? [];
+}
+
+
+export type CacheCourseMigrationOptions = {
+    cachedMigrations?: ReturnType<typeof loadCachedMigrations>,
+}
+
+export function cacheCourseMigrations(courseId: number, toCacheMigrations: SavedMigration[], options?:CacheCourseMigrationOptions) {
+    let {cachedMigrations} = options ?? {};
+    cachedMigrations ??= loadCachedMigrations();
+    const cachedCourseMigrations = loadCachedCourseMigrations(courseId);
+
+    function getToCacheVersion(migrationId: number) {
+        const migrations = toCacheMigrations.filter(toCache => toCache.id === migrationId);
+        if(migrations.length === 0) return undefined;
+        return migrations[0] as SavedMigration;
+    }
+
+    function hasCachedVersion(migrationId: number) {
+        const migrations = cachedCourseMigrations.filter(cached => cached.id === migrationId);
+        return migrations.length > 0;
+    }
+
+
+    let updatingMigrations = cachedCourseMigrations.map(cachedCourseMigration => ({
+            ...cachedCourseMigration,
+            ...getToCacheVersion(cachedCourseMigration.id),
+    }))
+    const remainingMigrations = toCacheMigrations.filter(migration => !hasCachedVersion(migration.id))
+
+    updatingMigrations = [
+        ...updatingMigrations,
+        ...remainingMigrations,
+    ].toSorted((a, b) => a.id - b.id);
+
+    cachedMigrations[courseId.toString()] = updatingMigrations;
+    localStorage.setItem('migrations', JSON.stringify(cachedMigrations));
+    return cachedMigrations;
+}

package/src/course/modules.ts

@@ -0,0 +1,113 @@
+import {Temporal} from "temporal-polyfill";
+import {IModuleData, IModuleItemData} from "../canvasDataDefs";
+import {formDataify, ICanvasCallConfig} from "../canvasUtils";
+
+
+import {fetchJson} from "@canvas/fetch/fetchJson";
+import {Page} from "@canvas/content/pages/Page";
+import {getPagedDataGenerator} from "@canvas/fetch/getPagedDataGenerator";
+import {IPageData} from "@canvas/content/pages/types";
+import {Discussion} from "@canvas/content/discussions/Discussion";
+
+export interface IModuleHaver {
+    getModules(config: ICanvasCallConfig): IModuleData[],
+}
+
+export interface GenerateModulesOptions {
+    include?: ('items' | 'content_details')[],
+    search_term?: string,
+    student_id?: string
+}
+
+
+export async function saveModuleItem(
+    courseId:number,
+    moduleId:number,
+    moduleItemId: number,
+    moduleItem: Partial<IModuleItemData>
+) {
+    return await fetchJson(`/api/v1/courses/${courseId}/modules/${moduleId}/modules/items/${moduleItemId}`, {
+        fetchInit: {
+            method: "PUT",
+            body: formDataify({ moduleItem: moduleItem }),
+        }
+    })
+}
+
+export function moduleGenerator(courseId:number, config?: ICanvasCallConfig<GenerateModulesOptions>) {
+    return getPagedDataGenerator<IModuleData>(`/api/v1/courses/${courseId}/modules`, config);
+}
+
+export async function changeModuleLockDate(courseId: number, module: IModuleData, targetDate: Temporal.PlainDate) {
+    const payload = {
+        module: {
+            unlock_at: targetDate.toString()
+        }
+    }
+    const url = `/api/v1/courses/${courseId}/modules/${module.id}`;
+    const result = fetchJson(url, {
+        fetchInit: {
+            method: 'PUT',
+            body: formDataify(payload)
+        }
+    })
+}
+
+
+export async function getModuleOverview(module: IModuleData, courseId: number) {
+    const overview = module.items.find(item =>
+        item.type === "Page" &&
+        item.title.toLowerCase().includes('overview')
+    );
+    if (!overview?.url) return; //skip this if it's not an overview
+
+    const url = overview.url.replace(/.*\/api\/v1/, '/api/v1')
+    const pageData = await fetchJson(url) as IPageData;
+    return new Page(pageData, courseId);
+}
+
+export function getModuleWeekNumber(module: Record<string, any>) {
+    const regex = /(week|module) (\d+)/i;
+    const match = module.name.match(regex);
+    let weekNumber = !match ? null : Number(match[1]);
+    if (!weekNumber) {
+        for (const moduleItem of module.items) {
+            if (!moduleItem.hasOwnProperty('title')) {
+                continue;
+            }
+            const match = moduleItem.title.match(regex);
+            if (match) {
+                weekNumber = match[2];
+            }
+        }
+    }
+    return weekNumber;
+}
+
+export async function getModulesByWeekNumber(modules: IModuleData[]) {
+    const modulesByWeekNumber: Record<string | number, IModuleData> = {};
+    for (const module of modules) {
+        const weekNumber = getModuleWeekNumber(module);
+        if (weekNumber) {
+            modulesByWeekNumber[weekNumber] = module;
+        }
+    }
+    return modulesByWeekNumber;
+}
+
+const isModuleItemTypeFunc = <T extends IModuleItemData>(typeString: string) => (item: IModuleItemData): item is T => {
+    return item.type === typeString;
+}
+
+export type PageItemData = IModuleItemData & { type: "Page" };
+export const isPageItemData = isModuleItemTypeFunc<PageItemData>("Page");
+
+export type AssignmentItemData = IModuleItemData & { type: "Assignment"; };
+export const isAssignmentItemData = isModuleItemTypeFunc<AssignmentItemData>("Assignment");
+
+export type DiscussionItemData = IModuleItemData & { type: "Discussion"; };
+export const isDiscussionItemData = isModuleItemTypeFunc<DiscussionItemData>("Discussion");
+
+export type QuizItemData = IModuleItemData & { type: "Quiz"; };
+export const isQuizItemData = isModuleItemTypeFunc<QuizItemData>("Quiz");
+

package/src/course/notABlueprintError.ts

@@ -0,0 +1,3 @@
+export class NotABlueprintError extends Error {
+    name = "NotABlueprintError"
+}

package/src/course/references/getReferencesForText.test.ts

@@ -0,0 +1,18 @@
+import getReferencesForText from "@/course/references/getReferencesForText";
+import {fetchJson} from "@/fetch/fetchJson";
+import {jest} from "@jest/globals";
+import mockCiteAsResponse from "@/course/references/mockCiteAsResponse";
+
+jest.mock('@/fetch/fetchJson', () => ({
+    fetchJson: jest.fn(),
+}))
+
+describe('getReferencesForText', () => {
+    const userEmail = 'ttestersson@unity.edu';
+    const testText = "The Hungry, Hungry Caterpillar";
+    (fetchJson as jest.Mock).mockImplementation(async () => mockCiteAsResponse)
+    it('passes email and text into url', async () => {
+        const refs = await getReferencesForText(testText, userEmail);
+
+    });
+});

package/src/course/references/getReferencesForText.ts

@@ -0,0 +1,12 @@
+import {fetchJson} from "@/fetch/fetchJson";
+import {IQueryParams} from "@/canvasUtils";
+import {apiGetConfig} from "@canvas/fetch/apiGetConfig";
+
+const baseUrl = 'https://api.citeas.org/product'
+
+export default async function getReferencesForText(text:string, userEmail:string, queryParams?:IQueryParams) {
+    queryParams ??= {};
+    queryParams.email = userEmail;
+    const result = await fetchJson(baseUrl, apiGetConfig(queryParams))
+    return result;
+}

package/src/course/references/getReferencesTemplate.ts

@@ -0,0 +1,28 @@
+import {DEV_TEMPLATE_COURSE_ID, REFERENCES_PAGE_URL_NAME} from "@/consts";
+import {IPageData} from "@/content/pages/types";
+import {Page} from "@/content/pages/Page";
+import PageKind from "@/content/pages/PageKind";
+
+
+const url = `/api/v1/courses/${DEV_TEMPLATE_COURSE_ID}/pages/${REFERENCES_PAGE_URL_NAME}`;
+
+export enum ReferenceExportType {
+    string,
+    pageData,
+    page,
+}
+
+function getReferenceTemplate() : Promise<string|undefined>;
+function getReferenceTemplate(type: ReferenceExportType.string) : Promise<string|undefined>;
+function getReferenceTemplate(type: ReferenceExportType.pageData) : Promise<IPageData|undefined>;
+async function getReferenceTemplate(type: ReferenceExportType.page) : Promise<Page|undefined>;
+async function getReferenceTemplate(type?: NonNullable<unknown>) {
+    const pageData = await PageKind.getByString(DEV_TEMPLATE_COURSE_ID, REFERENCES_PAGE_URL_NAME)
+
+    if(typeof type === 'undefined' || type === ReferenceExportType.string) return 'body' in pageData ? pageData.body : pageData.message;
+    if('message' in pageData) return undefined;
+    if(type === ReferenceExportType.pageData) return pageData;
+    if(type === ReferenceExportType.page) return pageData ? new Page(pageData, DEV_TEMPLATE_COURSE_ID) : undefined;
+}
+
+export default getReferenceTemplate;