alex/canvasManagement
1
0
Fork 0
mirror of https://github.com/alexmickelson/canvasManagement.git synced 2026-03-27 07:58:31 -06:00
Code Issues Packages Projects Releases Wiki Activity

refactoring files to be located by feature

Browse Source
This commit is contained in:
Alex Mickelson
2025-07-23 09:23:44 -06:00
parent 46e0c36916
commit c95c40f9e7
75 changed files with 279 additions and 303 deletions
Download Patch File Download Diff File Expand all files Collapse all files

10
src/services/canvas/canvasAssignmentGroupService.ts
View File

@@ -1,16 +1,14 @@
import { canvasApi, paginatedRequest } from "./canvasServiceUtils";
import { axiosClient } from "../axiosUtils";
import { CanvasAssignmentGroup } from "@/models/canvas/assignments/canvasAssignmentGroup";
import { LocalAssignmentGroup } from "@/models/local/assignment/localAssignmentGroup";
import { LocalAssignmentGroup } from "@/features/local/assignments/models/localAssignmentGroup";
import { rateLimitAwareDelete } from "./canvasWebRequestor";
export const canvasAssignmentGroupService = {
async getAll(courseId: number): Promise<CanvasAssignmentGroup[]> {
console.log("Requesting assignment groups");
const url = `${canvasApi}/courses/${courseId}/assignment_groups`;
const assignmentGroups = await paginatedRequest<
CanvasAssignmentGroup[]
>({
const assignmentGroups = await paginatedRequest<CanvasAssignmentGroup[]>({
url,
});
return assignmentGroups.flatMap((groupList) => groupList);
@@ -40,7 +38,9 @@ export const canvasAssignmentGroupService = {
canvasCourseId: number,
localAssignmentGroup: LocalAssignmentGroup
): Promise<void> {
console.log(`Updating assignment group: ${localAssignmentGroup.name}, ${localAssignmentGroup.canvasId}`);
console.log(
`Updating assignment group: ${localAssignmentGroup.name}, ${localAssignmentGroup.canvasId}`
);
if (!localAssignmentGroup.canvasId) {
throw new Error("Cannot update assignment group if canvas ID is null");
}

4
src/services/canvas/canvasAssignmentService.ts
View File

@@ -1,10 +1,10 @@
import { CanvasAssignment } from "@/models/canvas/assignments/canvasAssignment";
import { canvasApi, paginatedRequest } from "./canvasServiceUtils";
import { LocalAssignment } from "@/models/local/assignment/localAssignment";
import { LocalAssignment } from "@/features/local/assignments/models/localAssignment";
import { axiosClient } from "../axiosUtils";
import { markdownToHTMLSafe } from "../htmlMarkdownUtils";
import { CanvasRubricCreationResponse } from "@/models/canvas/assignments/canvasRubricCreationResponse";
import { assignmentPoints } from "@/models/local/assignment/utils/assignmentPointsUtils";
import { assignmentPoints } from "@/features/local/assignments/models/utils/assignmentPointsUtils";
import { getDateFromString } from "@/models/local/utils/timeUtils";
import { getRubricCriterion } from "./canvasRubricUtils";
import { LocalCourseSettings } from "@/models/local/localCourseSettings";

30
src/services/canvas/canvasPageService.ts
View File

@@ -1,5 +1,5 @@
import { CanvasPage } from "@/models/canvas/pages/canvasPageModel";
import { LocalCoursePage } from "@/models/local/page/localCoursePage";
import { LocalCoursePage } from "@/features/local/pages/localCoursePageModels";
import { canvasApi, paginatedRequest } from "./canvasServiceUtils";
import { markdownToHTMLSafe } from "../htmlMarkdownUtils";
import { axiosClient } from "../axiosUtils";
@@ -10,21 +10,21 @@ export const canvasPageService = {
async getAll(courseId: number): Promise<CanvasPage[]> {
console.log("requesting pages");
try {
const url = `${canvasApi}/courses/${courseId}/pages`;
const pages = await paginatedRequest<CanvasPage[]>({
url,
});
return pages.flatMap((pageList) => pageList);
// eslint-disable-next-line @typescript-eslint/no-explicit-any
} catch (error: any) {
if (error?.response?.status === 403) {
console.log(
"Canvas API error: 403 Forbidden for pages. Returning empty array."
);
return [];
const url = `${canvasApi}/courses/${courseId}/pages`;
const pages = await paginatedRequest<CanvasPage[]>({
url,
});
return pages.flatMap((pageList) => pageList);
// eslint-disable-next-line @typescript-eslint/no-explicit-any
} catch (error: any) {
if (error?.response?.status === 403) {
console.log(
"Canvas API error: 403 Forbidden for pages. Returning empty array."
);
return [];
}
throw error;
}
throw error;
}
},
async create(

7
src/services/canvas/canvasQuizService.ts
View File

@@ -1,17 +1,14 @@
import { CanvasQuiz } from "@/models/canvas/quizzes/canvasQuizModel";
import { axiosClient } from "../axiosUtils";
import { canvasApi, paginatedRequest } from "./canvasServiceUtils";
import { LocalQuiz } from "@/models/local/quiz/localQuiz";
import { markdownToHTMLSafe } from "../htmlMarkdownUtils";
import { getDateFromStringOrThrow } from "@/models/local/utils/timeUtils";
import { canvasAssignmentService } from "./canvasAssignmentService";
import {
LocalQuizQuestion,
QuestionType,
} from "@/models/local/quiz/localQuizQuestion";
import { CanvasQuizQuestion } from "@/models/canvas/quizzes/canvasQuizQuestionModel";
import { LocalCourseSettings } from "@/models/local/localCourseSettings";
import { escapeMatchingText } from "../utils/questionHtmlUtils";
import { LocalQuiz } from "@/features/local/quizzes/models/localQuiz";
import { LocalQuizQuestion, QuestionType } from "@/features/local/quizzes/models/localQuizQuestion";
export const getAnswers = (
question: LocalQuizQuestion,

35
src/services/canvas/canvasRubricUtils.ts
View File

@@ -1,22 +1,21 @@
import { RubricItem } from "@/models/local/assignment/rubricItem";
import { RubricItem } from "@/features/local/assignments/models/rubricItem";
export const getRubricCriterion = (rubric: RubricItem[]) => {
const criterion = rubric
.map((rubricItem) => ({
description: rubricItem.label,
points: rubricItem.points,
ratings: {
0: { description: "Full Marks", points: rubricItem.points },
1: { description: "No Marks", points: 0 },
},
}))
.reduce((acc, item, index) => {
return {
...acc,
[index]: item,
};
}, {} as { [key: number]: { description: string; points: number; ratings: { [key: number]: { description: string; points: number } } } });
.map((rubricItem) => ({
description: rubricItem.label,
points: rubricItem.points,
ratings: {
0: { description: "Full Marks", points: rubricItem.points },
1: { description: "No Marks", points: 0 },
},
}))
.reduce((acc, item, index) => {
return {
...acc,
[index]: item,
};
}, {} as { [key: number]: { description: string; points: number; ratings: { [key: number]: { description: string; points: number } } } });
return criterion
}
return criterion;
};

66
src/services/canvas/rubric.test.ts
View File

@@ -1,21 +1,21 @@
import { RubricItem } from "@/models/local/assignment/rubricItem";
import { RubricItem } from "@/features/local/assignments/models/rubricItem";
import { describe, expect, it } from "vitest";
import { getRubricCriterion } from "./canvasRubricUtils";
import { assignmentPoints } from "@/models/local/assignment/utils/assignmentPointsUtils";
import { assignmentPoints } from "@/features/local/assignments/models/utils/assignmentPointsUtils";
describe("can prepare rubric for canvas", () =>{
it("can parse normal rubric into criterion", () =>{
describe("can prepare rubric for canvas", () => {
it("can parse normal rubric into criterion", () => {
const rubric: RubricItem[] = [
{
label: "first",
points: 1
points: 1,
},
{
label: "second",
points: 2
points: 2,
},
]
const criterion = getRubricCriterion(rubric)
];
const criterion = getRubricCriterion(rubric);
expect(criterion).toStrictEqual({
0: {
@@ -24,7 +24,7 @@ describe("can prepare rubric for canvas", () =>{
ratings: {
0: { description: "Full Marks", points: 1 },
1: { description: "No Marks", points: 0 },
}
},
},
1: {
description: "second",
@@ -32,24 +32,23 @@ describe("can prepare rubric for canvas", () =>{
ratings: {
0: { description: "Full Marks", points: 2 },
1: { description: "No Marks", points: 0 },
}
}
})
})
},
},
});
});
it("can parse negative rubric into criterion", () =>{
it("can parse negative rubric into criterion", () => {
const rubric: RubricItem[] = [
{
label: "first",
points: 1
points: 1,
},
{
label: "second",
points: -2
points: -2,
},
]
const criterion = getRubricCriterion(rubric)
];
const criterion = getRubricCriterion(rubric);
expect(criterion).toStrictEqual({
0: {
@@ -58,7 +57,7 @@ describe("can prepare rubric for canvas", () =>{
ratings: {
0: { description: "Full Marks", points: 1 },
1: { description: "No Marks", points: 0 },
}
},
},
1: {
description: "second",
@@ -66,28 +65,27 @@ describe("can prepare rubric for canvas", () =>{
ratings: {
0: { description: "Full Marks", points: -2 },
1: { description: "No Marks", points: 0 },
}
}
})
})
},
},
});
});
it("negative rubric items do not contribute to the total", () =>{
it("negative rubric items do not contribute to the total", () => {
const rubric: RubricItem[] = [
{
label: "first",
points: 1
points: 1,
},
{
label: "second",
points: -2
points: -2,
},
{
label: "second",
points: 3
points: 3,
},
]
const points = assignmentPoints(rubric)
expect(points).toBe(4)
})
})
];
const points = assignmentPoints(rubric);
expect(points).toBe(4);
});
});

4
src/services/fileStorage/assignmentsFileStorageService.ts
View File

@@ -1,8 +1,8 @@
import {
localAssignmentMarkdown,
LocalAssignment,
} from "@/models/local/assignment/localAssignment";
import { assignmentMarkdownSerializer } from "@/models/local/assignment/utils/assignmentMarkdownSerializer";
} from "@/features/local/assignments/models/localAssignment";
import { assignmentMarkdownSerializer } from "@/features/local/assignments/models/utils/assignmentMarkdownSerializer";
import path from "path";
import { directoryOrFileExists } from "./utils/fileSystemUtils";
import { promises as fs } from "fs";

19
src/services/fileStorage/courseItemFileStorageService.ts
View File

@@ -4,23 +4,20 @@ import fs from "fs/promises";
import {
LocalAssignment,
localAssignmentMarkdown,
} from "@/models/local/assignment/localAssignment";
import {
LocalQuiz,
localQuizMarkdownUtils,
} from "@/models/local/quiz/localQuiz";
import {
LocalCoursePage,
localPageMarkdownUtils,
} from "@/models/local/page/localCoursePage";
import { assignmentMarkdownSerializer } from "@/models/local/assignment/utils/assignmentMarkdownSerializer";
import { quizMarkdownUtils } from "@/models/local/quiz/utils/quizMarkdownUtils";
} from "@/features/local/assignments/models/localAssignment";
import { assignmentMarkdownSerializer } from "@/features/local/assignments/models/utils/assignmentMarkdownSerializer";
import {
CourseItemReturnType,
CourseItemType,
typeToFolder,
} from "@/models/local/courseItemTypes";
import { getCoursePathByName } from "./globalSettingsFileStorageService";
import {
localPageMarkdownUtils,
LocalCoursePage,
} from "@/features/local/pages/localCoursePageModels";
import { LocalQuiz, localQuizMarkdownUtils } from "@/features/local/quizzes/models/localQuiz";
import { quizMarkdownUtils } from "@/features/local/quizzes/models/utils/quizMarkdownUtils";
const getItemFileNames = async (
courseName: string,

2
src/services/fileStorage/fileStorageService.ts
View File

@@ -3,7 +3,7 @@ import path from "path";
import { basePath, directoryOrFileExists } from "./utils/fileSystemUtils";
import { assignmentsFileStorageService } from "./assignmentsFileStorageService";
import { quizFileStorageService } from "./quizFileStorageService";
import { pageFileStorageService } from "./pageFileStorageService";
import { pageFileStorageService } from "../../features/local/pages/pageFileStorageService";
import { moduleFileStorageService } from "./moduleFileStorageService";
import { settingsFileStorageService } from "./settingsFileStorageService";
import { getCoursePathByName } from "./globalSettingsFileStorageService";

7
src/services/fileStorage/globalSettingsFileStorageService.ts
View File

@@ -46,11 +46,4 @@ export const updateGlobalSettings = async (globalSettings: GlobalSettings) => {
zodGlobalSettings.parse(globalSettings)
);
await fs.writeFile(SETTINGS_FILE_PATH, globalSettingsString, "utf-8");
// await Promise.all(
// globalSettings.courses.map(async (course) => {
// const coursePath = await getCoursePathByName(course.name);
// await fs.mkdir(coursePath, { recursive: true });
// })
// );
};

66
src/services/fileStorage/pageFileStorageService.ts
View File

@@ -1,66 +0,0 @@
import {
localPageMarkdownUtils,
LocalCoursePage,
} from "@/models/local/page/localCoursePage";
import { promises as fs } from "fs";
import path from "path";
import { courseItemFileStorageService } from "./courseItemFileStorageService";
import { getCoursePathByName } from "./globalSettingsFileStorageService";
export const pageFileStorageService = {
getPage: async (courseName: string, moduleName: string, name: string) =>
await courseItemFileStorageService.getItem(
courseName,
moduleName,
name,
"Page"
),
getPages: async (courseName: string, moduleName: string) =>
await courseItemFileStorageService.getItems(courseName, moduleName, "Page"),
async updatePage({
courseName,
moduleName,
pageName,
page,
}: {
courseName: string;
moduleName: string;
pageName: string;
page: LocalCoursePage;
}) {
const courseDirectory = await getCoursePathByName(courseName);
const folder = path.join(courseDirectory, moduleName, "pages");
await fs.mkdir(folder, { recursive: true });
const filePath = path.join(
courseDirectory,
moduleName,
"pages",
pageName + ".md"
);
const pageMarkdown = localPageMarkdownUtils.toMarkdown(page);
console.log(`Saving page ${filePath}`);
await fs.writeFile(filePath, pageMarkdown);
},
async delete({
courseName,
moduleName,
pageName,
}: {
courseName: string;
moduleName: string;
pageName: string;
}) {
const courseDirectory = await getCoursePathByName(courseName);
const filePath = path.join(
courseDirectory,
moduleName,
"pages",
pageName + ".md"
);
console.log("removing page", filePath);
await fs.unlink(filePath);
},
};

4
src/services/fileStorage/quizFileStorageService.ts
View File

@@ -1,9 +1,9 @@
import { LocalQuiz } from "@/models/local/quiz/localQuiz";
import { quizMarkdownUtils } from "@/models/local/quiz/utils/quizMarkdownUtils";
import path from "path";
import { promises as fs } from "fs";
import { courseItemFileStorageService } from "./courseItemFileStorageService";
import { getCoursePathByName } from "./globalSettingsFileStorageService";
import { LocalQuiz } from "@/features/local/quizzes/models/localQuiz";
import { quizMarkdownUtils } from "@/features/local/quizzes/models/utils/quizMarkdownUtils";
export const quizFileStorageService = {
getQuiz: async (courseName: string, moduleName: string, quizName: string) =>

2
src/services/fileStorage/settingsFileStorageService.ts
View File

@@ -5,7 +5,7 @@ import {
import { promises as fs } from "fs";
import path from "path";
import { basePath, directoryOrFileExists } from "./utils/fileSystemUtils";
import { AssignmentSubmissionType } from "@/models/local/assignment/assignmentSubmissionType";
import { AssignmentSubmissionType } from "@/features/local/assignments/models/assignmentSubmissionType";
import {
getCoursePathByName,
getGlobalSettings,

2
src/services/fileStorage/utils/lectureUtils.ts
View File

@@ -1,5 +1,5 @@
import { getWeekNumber } from "@/app/course/[courseName]/calendar/calendarMonthUtils";
import { extractLabelValue } from "@/models/local/assignment/utils/markdownUtils";
import { extractLabelValue } from "@/features/local/assignments/models/utils/markdownUtils";
import { Lecture } from "@/models/local/lecture";
import { getDateFromStringOrThrow } from "@/models/local/utils/timeUtils";

4
src/services/serverFunctions/router/app.ts
View File

@@ -1,12 +1,12 @@
import { createTrpcContext } from "../context";
import { createCallerFactory, router } from "../trpcSetup";
import { assignmentRouter } from "./assignmentRouter";
import { assignmentRouter } from "../../../features/local/assignments/assignmentRouter";
import { canvasFileRouter } from "./canvasFileRouter";
import { directoriesRouter } from "./directoriesRouter";
import { globalSettingsRouter } from "./globalSettingsRouter";
import { lectureRouter } from "./lectureRouter";
import { moduleRouter } from "./moduleRouter";
import { pageRouter } from "./pageRouter";
import { pageRouter } from "../../../features/local/pages/pageRouter";
import { quizRouter } from "./quizRouter";
import { settingsRouter } from "./settingsRouter";

116
src/services/serverFunctions/router/assignmentRouter.ts
View File

@@ -1,116 +0,0 @@
import publicProcedure from "../procedures/public";
import { z } from "zod";
import { router } from "../trpcSetup";
import { fileStorageService } from "@/services/fileStorage/fileStorageService";
import { zodLocalAssignment } from "@/models/local/assignment/localAssignment";
export const assignmentRouter = router({
getAssignment: publicProcedure
.input(
z.object({
courseName: z.string(),
moduleName: z.string(),
assignmentName: z.string(),
})
)
.query(async ({ input: { courseName, moduleName, assignmentName } }) => {
const assignment = await fileStorageService.assignments.getAssignment(
courseName,
moduleName,
assignmentName
);
// console.log(assignment);
return assignment;
}),
getAllAssignments: publicProcedure
.input(
z.object({
courseName: z.string(),
moduleName: z.string(),
})
)
.query(async ({ input: { courseName, moduleName } }) => {
const assignments = await fileStorageService.assignments.getAssignments(
courseName,
moduleName
);
return assignments;
}),
createAssignment: publicProcedure
.input(
z.object({
courseName: z.string(),
moduleName: z.string(),
assignmentName: z.string(),
assignment: zodLocalAssignment,
})
)
.mutation(
async ({
input: { courseName, moduleName, assignmentName, assignment },
}) => {
await fileStorageService.assignments.updateOrCreateAssignment({
courseName,
moduleName,
assignmentName,
assignment,
});
}
),
updateAssignment: publicProcedure
.input(
z.object({
courseName: z.string(),
moduleName: z.string(),
previousModuleName: z.string(),
previousAssignmentName: z.string(),
assignmentName: z.string(),
assignment: zodLocalAssignment,
})
)
.mutation(
async ({
input: {
courseName,
moduleName,
assignmentName,
assignment,
previousModuleName,
previousAssignmentName,
},
}) => {
await fileStorageService.assignments.updateOrCreateAssignment({
courseName,
moduleName,
assignmentName,
assignment,
});
if (
assignmentName !== previousAssignmentName ||
moduleName !== previousModuleName
) {
await fileStorageService.assignments.delete({
courseName,
moduleName: previousModuleName,
assignmentName: previousAssignmentName,
});
}
}
),
deleteAssignment: publicProcedure
.input(
z.object({
courseName: z.string(),
moduleName: z.string(),
assignmentName: z.string(),
})
)
.mutation(async ({ input: { courseName, moduleName, assignmentName } }) => {
await fileStorageService.assignments.delete({
courseName,
moduleName,
assignmentName,
});
}),
});

107
src/services/serverFunctions/router/pageRouter.ts
View File

@@ -1,107 +0,0 @@
import publicProcedure from "../procedures/public";
import { z } from "zod";
import { router } from "../trpcSetup";
import { fileStorageService } from "@/services/fileStorage/fileStorageService";
import { zodLocalCoursePage } from "@/models/local/page/localCoursePage";
export const pageRouter = router({
getPage: publicProcedure
.input(
z.object({
courseName: z.string(),
moduleName: z.string(),
pageName: z.string(),
})
)
.query(async ({ input: { courseName, moduleName, pageName } }) => {
return await fileStorageService.pages.getPage(
courseName,
moduleName,
pageName
);
}),
getAllPages: publicProcedure
.input(
z.object({
courseName: z.string(),
moduleName: z.string(),
})
)
.query(async ({ input: { courseName, moduleName } }) => {
return await fileStorageService.pages.getPages(courseName, moduleName);
}),
createPage: publicProcedure
.input(
z.object({
courseName: z.string(),
moduleName: z.string(),
pageName: z.string(),
page: zodLocalCoursePage,
})
)
.mutation(async ({ input: { courseName, moduleName, pageName, page } }) => {
await fileStorageService.pages.updatePage({
courseName,
moduleName,
pageName,
page,
});
}),
updatePage: publicProcedure
.input(
z.object({
courseName: z.string(),
moduleName: z.string(),
previousModuleName: z.string(),
previousPageName: z.string(),
pageName: z.string(),
page: zodLocalCoursePage,
})
)
.mutation(
async ({
input: {
courseName,
moduleName,
pageName,
page,
previousModuleName,
previousPageName,
},
}) => {
await fileStorageService.pages.updatePage({
courseName,
moduleName,
pageName,
page,
});
if (
pageName !== previousPageName ||
moduleName !== previousModuleName
) {
await fileStorageService.pages.delete({
courseName,
moduleName: previousModuleName,
pageName: previousPageName,
});
}
}
),
deletePage: publicProcedure
.input(
z.object({
courseName: z.string(),
moduleName: z.string(),
pageName: z.string(),
})
)
.mutation(async ({ input: { courseName, moduleName, pageName } }) => {
await fileStorageService.pages.delete({
courseName,
moduleName,
pageName,
});
}),
});

2
src/services/serverFunctions/router/quizRouter.ts
View File

@@ -2,7 +2,7 @@ import publicProcedure from "../procedures/public";
import { z } from "zod";
import { router } from "../trpcSetup";
import { fileStorageService } from "@/services/fileStorage/fileStorageService";
import { zodLocalQuiz } from "@/models/local/quiz/localQuiz";
import { zodLocalQuiz } from "@/features/local/quizzes/models/localQuiz";
export const quizRouter = router({
getQuiz: publicProcedure