feat: added the attendance and added a way for the restmanager to handle non json response

Author: game2822

.gitignore

@@ -139,3 +139,4 @@ grades.json
 subjects.json
 timetable.json
 timetable.json
+attendance.json

examples/attendance.ts

@@ -0,0 +1,46 @@
+process.env.NODE_TLS_REJECT_UNAUTHORIZED = "0";
+import readline from "readline";
+import fs from "fs";
+import dotenv from "dotenv";
+import { LoginWithToken } from "../src";
+
+dotenv.config();
+
+const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+});
+
+const askQuestion = (query: string): Promise<string> => {
+    return new Promise(resolve => rl.question(query, resolve));
+};
+
+const main = async () => {
+    try {
+        const url = process.env.INSTANCE_URL ?? "";
+        const refreshToken = process.env.REFRESH_TOKEN ?? "";
+        const userId = process.env.USER_ID ?? "";
+        const deviceId = process.env.DEVICE_ID ?? "";
+
+        // Refresh token and get device ID
+        console.log("Refreshing token...");
+        const smartschool = await LoginWithToken(url, refreshToken, deviceId);
+        console.log("Token refreshed successfully.");
+
+        // Fetch attendance items
+        console.log("\nFetching attendance items...");
+        const attendanceItems = await smartschool.GetAttendanceItems();
+
+        fs.writeFileSync("attendance.json", JSON.stringify(attendanceItems, null, 2));
+        console.log("\nAttendance items fetched successfully:");
+        console.log(`Found ${attendanceItems.length} attendance items.`);
+        console.log(JSON.stringify(attendanceItems, null, 2));
+    } catch (error) {
+        console.error("\nAn error occurred:");
+        console.error(error);
+    } finally {
+        rl.close();
+    }
+};
+
+main();

src/rest/RESTManager.ts

@@ -9,7 +9,7 @@ export class RestManager {
         this.baseURL = baseURL;
     }
 
-    private async sendRequest<T>(options: RequestOptions): Promise<T> {
+    private async sendRequest<T>(options: RequestOptions,textonly?: boolean): Promise<T> {
         const { method, path, body, headers } = options;
         const url = `${this.baseURL}/${path}`;
 
@@ -34,18 +34,19 @@ export class RestManager {
         });
 
         if (!response.ok) {
-            const responseData = await response.json();
+            const responseData = await response.text();
             console.error(`Error response from ${method} ${url}:`, responseData);
             console.error("Request Headers:", headers);
             console.error("Request Body:", body);
             throw new Error(`${response.status}: ${JSON.stringify(responseData)}`);
         }
-
-        const responseData = await response.json();
-       // console.log("Body:", body);
-       // console.log("Response Data:", responseData);
-       // console.log("headers:", headers);
-        return responseData as T;
+        if (textonly === undefined || textonly === false) {
+            const responseData = await response.json();
+            return responseData as T;
+        }else {
+            const responseData = await response.text();
+            return responseData as unknown as T;
+        }
     }
 
     async delete<T>(path: string, params?: Record<string, any>, options?: RequestOptions): Promise<T> {
@@ -69,7 +70,7 @@ export class RestManager {
         });
     }
 
-    async post<T>(path: string, body: any, params?: Record<string, any>, options?: RequestOptions): Promise<T> {
+    async post<T>(path: string, body: any, params?: Record<string, any>, options?: RequestOptions,textonly?: boolean): Promise<T> {
         const urlParams = new URLSearchParams(params).toString();
         const urlPath = urlParams ? `${path}?${urlParams}` : path;
         console.log("POST URL Params:", urlParams);
@@ -79,7 +80,7 @@ export class RestManager {
             path: urlPath,
             body,
             headers: options?.headers
-        });
+        }, textonly);
     }
 
     async put<T>(path: string, body: any, options?: RequestOptions): Promise<T> {

src/routes/Attendance.ts

@@ -5,41 +5,73 @@ import { absenceFileStateIncluded, absenceReasonIncluded } from "../types/Attend
 import { BaseDataResponse, BaseResponse } from "../types/RequestHandler";
 import { AttendanceItemState, AttendanceItemType } from "../util/Constants";
 import { getSingleRelation } from "../util/Relations";
+import { extractBaseUrl } from "../util/URL";
 
-const manager = new RestManager(BASE_URL());
 
-export const GetAttendanceItems = async (userId: string, accessToken: string): Promise<Array<AttendanceItem>> => {
-    const response = await manager.get<BaseResponse>(ATTENDANCE_FILES(), {
-        "filter[student.id]":               userId,
-        "filter[currentState.absenceType]": "ABSENCE,CLATENESS",
-        "filter[absenceFile]":              "currentState",
-        "include":                          "currentState,currentState.absenceReason,currentState.absenceRecurrence",
-        "fields[absenceFileState]":         "creationDateTime,absenceStartDateTime,absenceEndDateTime,absenceType,absenceFileStatus,absenceReason,absenceRecurrence",
-        "fields[absenceReason]":            "code,longLabel"
-    }, {
-        Authorization: `Bearer ${accessToken}`
-    });
-
-    const includedMap = new Map<string, unknown>();
-    for (const item of response.included ?? []) {
-        includedMap.set(`${item.type}:${item.id}`, item);
+function parseDate(date: string): Date {
+    const clean = date.replace(/^\w+\.\s*/, "")
+    const months: Record<string, number> = {
+        "janvier":   0, "février":   1, "mars":      2,
+        "avril":     3, "mai":       4, "juin":      5,
+        "juillet":   6, "août":      7, "septembre": 8,
+        "octobre":   9, "novembre":  10, "décembre":  11
+    };
+    const match = clean.match(/^(\d{1,2}) (\w+) (\d{4})$/);
+    if (!match) {
+        throw new Error(`Invalid date format: ${date}`);
+    }
+    const [, day, month, year] = match;
+    const monthIndex = months[month.toLowerCase()];
+    if (monthIndex === undefined) {
+        throw new Error(`Invalid month name: ${month}`);
     }
+    return new Date(Number(year), monthIndex, Number(day));
+}
+
+export const GetAttendanceItems = async (url:string, userId: string, accessToken: string, mobileId: string): Promise<Array<AttendanceItem>> => {
+    const [base] = extractBaseUrl(url);
+    const manager = new RestManager(base);
+
+    const body = new URLSearchParams(
+        { pupilID: userId.split("_")[1] }
+    );
+    const responsetext = await manager.post<any>(
+        ATTENDANCE_FILES(),
+        body,
+        undefined,
+        {
+            headers: {
+                "Content-Type": "application/x-www-form-urlencoded",
+                "Authorization": `Bearer ${accessToken}`,
+                "Accept-Language": "fr",
+                "SmscMobileId": mobileId
+            }
+    }, 
+    true
+);
 
-    return (Array.isArray(response.data) ? response.data : [])
-        .filter((item): item is BaseDataResponse<"absenceFile"> => item.type === "absenceFile")
-        .map(absenceItem => {
-            const fileId = getSingleRelation(absenceItem.relationships.currentState)?.id;
-            const file = fileId ? includedMap.get("absenceFileState:" + fileId) as absenceFileStateIncluded : null;
-            const reasonId = getSingleRelation(file?.relationships?.absenceReason)?.id;
-            const reason = reasonId ? includedMap.get("absenceReason:" + reasonId) as absenceReasonIncluded : null;
-            return new AttendanceItem(
-                absenceItem.id,
-                new Date(file?.attributes?.creationDateTime ?? ""),
-                new Date(file?.attributes?.absenceStartDateTime ?? ""),
-                new Date(file?.attributes?.absenceEndDateTime ?? ""),
-                file?.attributes?.absenceType ?? AttendanceItemType.ABSENCE,
-                file?.attributes?.absenceFileStatus ?? AttendanceItemState.OPEN,
-                reason?.attributes?.longLabel ?? ""
-            );
-        });
+    const response = JSON.parse(responsetext);
+    const attendanceItems: Array<AttendanceItem> = [];
+
+    const currentYear = response.year_label;
+    const currentYearAttendance = response.presences?.[currentYear] || [];
+
+    for (const attendance of currentYearAttendance) {
+        const attendanceData = attendance.am || attendance.pm || attendance.full;
+        
+        if (attendanceData) {
+            const date = parseDate(attendanceData.formattedDate);
+            
+            attendanceItems.push(new AttendanceItem(
+                attendanceData.codeKey || "",
+                date,
+                new Date(date), // Start date
+                new Date(date), // End date
+                attendanceData.codeDescr || AttendanceItemType.ABSENCE,
+                AttendanceItemState.OPEN,
+                attendanceData.motivation || attendanceData.codeDescr || ""
+            ));
+        }
+    }
+    return attendanceItems;
 };

src/structures/Smartschool.ts

@@ -53,7 +53,7 @@ export class SmartSchool {
     }
     async GetAttendanceItems(): Promise<Array<AttendanceItem>> {
         await this.refreshAccessToken();
-        return GetAttendanceItems(this.userId, this.accessToken);
+        return GetAttendanceItems(this.refreshURL, this.userId, this.accessToken, this.SMSCMobileID);
     }
     async GetGradesForPeriod(period?: string): Promise<Array<Subject>> {
         await this.refreshAccessToken();