Implémentation de Alise

package.json

@@ -23,6 +23,7 @@
     "@react-navigation/native": "^6.1.17",
     "@react-navigation/native-stack": "^6.9.26",
     "@react-navigation/stack": "^6.4.0",
+    "alise-api": "^0.1.2",
     "axios": "^1.7.7",
     "buffer": "^6.0.3",
     "cal-parser": "^1.0.2",

src/providers/AlertProvider.tsx

@@ -157,7 +157,9 @@ const AlertProvider = ({ children }: AlertProviderProps) => {
                   <Pressable
                     key={title}
                     onPress={() => {
-                      onPress();
+                      if (onPress) {
+                        onPress();
+                      }
                       hideAlert();
                     }}
                     style={({ pressed }) => [

src/router/helpers/types.ts

@@ -137,6 +137,7 @@ export type RouteParameters = {
   ExternalTurboselfLogin: undefined;
   ExternalArdLogin: undefined;
   ExternalIzlyLogin: undefined;
+  ExternalAliseLogin: undefined;
   IzlyActivation: { username: string, password: string };
   PriceError: { account: Client, accountId: string };
   QrcodeScanner: { accountID: string };

src/router/screens/settings/index.ts

@@ -25,6 +25,7 @@ import PriceBeforeScan from "@/views/settings/ExternalAccount/PriceBeforeScan";
 import SettingsFlagsInfos from "@/views/settings/SettingsFlagsInfos";
 import ExternalIzlyLogin from "@/views/settings/ExternalAccount/Izly";
 import IzlyActivation from "@/views/settings/ExternalAccount/IzlyActivation";
+import ExternalAliseLogin from "@/views/settings/ExternalAccount/Alise";
 
 const settingsScreens = [
   createScreen("Settings", Settings, {
@@ -101,6 +102,9 @@ const settingsScreens = [
   createScreen("ExternalIzlyLogin", ExternalIzlyLogin, {
     headerTitle: "Connexion à Izly",
   }),
+  createScreen("ExternalAliseLogin", ExternalAliseLogin, {
+    headerTitle: "Connexion à Alise",
+  }),
 
   createScreen("IzlyActivation", IzlyActivation, {
     headerTitle: "Configuration de Izly",

src/services/alise/balance.ts

@@ -0,0 +1,14 @@
+import type { AliseAccount } from "@/stores/account/types";
+import type { Balance } from "../shared/Balance";
+
+export const getBalance = async (account: AliseAccount, force = false): Promise<Array<Balance>> => {
+  const balance = force ? (await account.authentication.session.getInformations()).balance : account.authentication.session.account?.balance ?? 0;
+  const mealPrice = account.authentication.mealPrice;
+
+  return [{
+    amount: balance,
+    currency: "€",
+    remaining: Math.floor(balance / (mealPrice ?? 0)),
+    label: "Self"
+  }];
+};

src/services/alise/bookings.ts

@@ -0,0 +1,26 @@
+import type { AliseAccount } from "@/stores/account/types";
+import type { BookingDay, BookingTerminal } from "../shared/Booking";
+
+export const getBookings = async (account: AliseAccount, force = false): Promise<BookingTerminal[]> => {
+  const bookings = force ? await account.authentication.session.getBookings() : await account.authentication.bookings;
+  return [{
+    id: "",
+    terminalLabel: "Self",
+    days: bookings.map((day) => ({
+      id: (day.identifier ?? ""),
+      canBook: day.canBook,
+      date: day.date,
+      booked: day.booked
+    })),
+    account: account
+  }];
+};
+
+export const bookDay = async (account: AliseAccount, id: string, date: Date, booked: boolean): Promise<BookingDay> => {
+  const bookedDay = await account.authentication.session.bookDay(id, 1, !booked);
+  return {
+    id: bookedDay.identifier ?? "",
+    canBook: bookedDay.canBook,
+    booked: bookedDay.booked,
+  };
+};

src/services/alise/history.ts

@@ -0,0 +1,12 @@
+import type { AliseAccount } from "@/stores/account/types";
+import type { ReservationHistory } from "../shared/ReservationHistory";
+
+export const getHistory = async (account: AliseAccount): Promise<ReservationHistory[]> => {
+  const history = await account.authentication.session.getFinancialHistory();
+  return (history ?? []).map((item) => ({
+    timestamp: item.date.getTime(),
+    amount: item.amount,
+    currency: "€",
+    label: item.label,
+  }));
+};

src/services/alise/reload.ts

@@ -0,0 +1,16 @@
+import type { AliseAccount } from "@/stores/account/types";
+import { authenticateWithCredentials } from "alise-api";
+
+export const reload = async (account: AliseAccount): Promise<AliseAccount["authentication"]> => {
+  const auth = { ...account.authentication };
+  const session = await authenticateWithCredentials(auth.username, auth.password, auth.schoolID);
+  const bookings = await session.getBookings();
+  return {
+    session,
+    schoolID: auth.schoolID,
+    username: auth.username,
+    password: auth.password,
+    mealPrice: auth.mealPrice,
+    bookings: bookings
+  };
+};

src/services/balance.ts

@@ -1,7 +1,7 @@
 import {AccountService, type ExternalAccount} from "@/stores/account/types";
 import type {Balance} from "./shared/Balance";
 
-export const balanceFromExternal = async (account: ExternalAccount): Promise<Balance[]> => {
+export const balanceFromExternal = async (account: ExternalAccount, force = false): Promise<Balance[]> => {
   switch (account.service) {
     case AccountService.Turboself: {
       const { getBalance } = await import("./turboself/balance");
@@ -15,6 +15,10 @@ export const balanceFromExternal = async (account: ExternalAccount): Promise<Bal
       const { balance } = await import("./izly/balance");
       return balance(account);
     }
+    case AccountService.Alise: {
+      const { getBalance } = await import("./alise/balance");
+      return getBalance(account, force);
+    }
     default: {
       return [];
     }

src/services/booking.ts

@@ -1,7 +1,7 @@
 import { AccountService, type ExternalAccount } from "@/stores/account/types";
 import type { BookingDay, BookingTerminal } from "./shared/Booking";
 
-export const getBookingsAvailableFromExternal = async (account: ExternalAccount, weekNumber?: number): Promise<BookingTerminal[]> => {
+export const getBookingsAvailableFromExternal = async (account: ExternalAccount, weekNumber?: number, force = false): Promise<BookingTerminal[]> => {
   switch (account.service) {
     case AccountService.Turboself: {
       const { getBookingWeek } = await import("./turboself/booking");
@@ -14,6 +14,11 @@ export const getBookingsAvailableFromExternal = async (account: ExternalAccount,
       // TODO: Implement ARD
       return [];
     }
+    case AccountService.Alise: {
+      const { getBookings } = await import("./alise/bookings");
+      const bookings = await getBookings(account, force);
+      return bookings;
+    }
     default: {
       return [];
     }
@@ -27,6 +32,11 @@ export const bookDayFromExternal = async (account: ExternalAccount, id: string,
       const bookedDay = await bookDay(account, id, date, booked);
       return bookedDay;
     }
+    case AccountService.Alise: {
+      const { bookDay } = await import("./alise/bookings");
+      const bookedDay = await bookDay(account, id, date, booked);
+      return bookedDay;
+    }
     case AccountService.ARD: {
       return undefined;
     }

src/services/ecoledirecte/attendance.ts

@@ -8,7 +8,7 @@ import {Absence} from "@/services/shared/Absence";
 import {Delay} from "@/services/shared/Delay";
 
 const decodeDelay = (item: AttendanceItem): Delay => {
-  const timeInterval = dateStringAsTimeInterval(item.displayDate); 
+  const timeInterval = dateStringAsTimeInterval(item.displayDate);
   const duration = (timeInterval?.end && timeInterval.start) ? getDuration(timeInterval).getTime() / (60 * 1000): 0;
   return {
     id: item.id.toString(),

src/services/ecoledirecte/chats.ts

@@ -19,8 +19,8 @@ export const getChats = async (account: EcoleDirecteAccount): Promise<Chat[]> =>
 };
 
 const cleanMessage = (message: string) => {
-  return message.replace(/>\s+/g, '>').replace(/&nbsp;/g, ' ');
-}
+  return message.replace(/>\s+/g, ">").replace(/&nbsp;/g, " ");
+};
 
 export const getChatMessages = async (account: EcoleDirecteAccount, chat: Chat): Promise<ChatMessage> => {
   if (!account.instance)

src/services/ecoledirecte/homework.ts

@@ -8,8 +8,8 @@ import { AttachmentType } from "../shared/Attachment";
 import { formatDate } from "@/services/ecoledirecte/format-date";
 
 const cleanContent = (message: string) => {
-  return message.replace(/>\s+/g, '>').replace(/ /g, ' ');
-}
+  return message.replace(/>\s+/g, ">").replace(/ /g, " ");
+};
 
 export const getHomeworkForWeek = async (
   account: EcoleDirecteAccount,

src/services/ecoledirecte/time-interval.ts

@@ -8,74 +8,74 @@ const months = ["janvier", "février", "mars", "avril", "mai", "juin", "juillet"
 /**
 * @param str "A string containing a date formatted as "mercredi 21 février 2024 de 08:10", will return the date for the specified day and hour"
 */
-export function dateAsISO860(str: string): string {
+export function dateAsISO860 (str: string): string {
   const parts = str.split(" ");
   const timeIndex = parts.findIndex(part => part.includes(":"));
   const hour = parts[timeIndex].split(":");
   const monthIndex = parts.findIndex(part => months.includes(part));
-  
+
   return (new Date(
-      Number(parts[monthIndex + 1]),
-      months.indexOf(parts[monthIndex]),
-      Number(parts[monthIndex - 1]),
-      Number(hour[0]),
-      Number(hour[1])
+    Number(parts[monthIndex + 1]),
+    months.indexOf(parts[monthIndex]),
+    Number(parts[monthIndex - 1]),
+    Number(hour[0]),
+    Number(hour[1])
   )).toISOString();
 }
 
-export function dateStringAsTimeInterval(
+export function dateStringAsTimeInterval (
   str: string,
 ): Timeinterval | undefined {
   if (str.includes("du")) {
-      /**
+    /**
        * @example
        * str is equal to "du mercredi 21 février 2024 au jeudi 22 février 2024"
        * or "du mercredi 27 novembre 2024 à 08:10 au vendredi 06 décembre 2024 à 08:10"
        */
-      const [startPart, endPart] = str.split("au").map(part => part.trim());
-      let start = startPart.replace("du", "").trim();
-      let end = endPart.trim();
+    const [startPart, endPart] = str.split("au").map(part => part.trim());
+    let start = startPart.replace("du", "").trim();
+    let end = endPart.trim();
 
-      if (!start.includes(":")) {
-          start += " de 00:00";
-      } else {
-          start = start.replace(" à ", " de ");
-      }
+    if (!start.includes(":")) {
+      start += " de 00:00";
+    } else {
+      start = start.replace(" à ", " de ");
+    }
 
-      if (!end.includes(":")) {
-          end += " de 23:59";
-      } else {
-          end = end.replace(" à ", " de ");
-      }
+    if (!end.includes(":")) {
+      end += " de 23:59";
+    } else {
+      end = end.replace(" à ", " de ");
+    }
 
-      return {
-          start: dateAsISO860(start),
-          end: dateAsISO860(end)
-      } as Timeinterval;
+    return {
+      start: dateAsISO860(start),
+      end: dateAsISO860(end)
+    } as Timeinterval;
   }
-  
+
   if (str.includes("le")) {
-      /**
+    /**
        * @example
        * str is equal to "le mercredi 21 février 2024 de 08:10 à 16:10"
        * or "le jeudi 22 février 2024"
        */
-      const parts = str.split("à");
-      let startDate: string;
-      let endDate: string;
+    const parts = str.split("à");
+    let startDate: string;
+    let endDate: string;
 
-      // It's a full day ("le mercredi 21 février 2024")
-      if (!str.includes(":")) {
-          startDate = `${parts[0].replace("le", "").trim()} de 00:00`;
-          endDate = `${parts[0].split("de")[0].replace("le", "").trim()} de 23:59`;
-      } else {
-          startDate = parts[0].replace("le", "").trim();
-          endDate = `${parts[0].split("de")[0].replace("le", "").trim()} de ${parts[1].trim()}`;
-      }
+    // It's a full day ("le mercredi 21 février 2024")
+    if (!str.includes(":")) {
+      startDate = `${parts[0].replace("le", "").trim()} de 00:00`;
+      endDate = `${parts[0].split("de")[0].replace("le", "").trim()} de 23:59`;
+    } else {
+      startDate = parts[0].replace("le", "").trim();
+      endDate = `${parts[0].split("de")[0].replace("le", "").trim()} de ${parts[1].trim()}`;
+    }
 
-      const start = dateAsISO860(startDate);
-      const end = dateAsISO860(endDate);
-      return { start: start, end: end } as Timeinterval;
+    const start = dateAsISO860(startDate);
+    const end = dateAsISO860(endDate);
+    return { start: start, end: end } as Timeinterval;
   }
   return undefined;
 }
@@ -100,6 +100,6 @@ export const getDurationInHours = (interval: Timeinterval): string => {
   const diff = new Date(interval.end).getTime() - new Date(interval.start).getTime();
   const hours = Math.floor(diff / (1000 * 60 * 60));
   const minutes = Math.floor((diff % (1000 * 60 * 60)) / (1000 * 60));
-  
-  return `${hours}h${minutes.toString().padStart(2, '0')}`;
+
+  return `${hours}h${minutes.toString().padStart(2, "0")}`;
 };

src/services/reload-account.ts

@@ -25,6 +25,11 @@ export async function reload <T extends Account> (account: T): Promise<Reconnect
       // keep instance the same
       return { instance: undefined, authentication: auth };
     }
+    case AccountService.Alise: {
+      const { reload } = await import("./alise/reload");
+      const auth = await reload(account);
+      return { instance: undefined, authentication: auth };
+    }
     case AccountService.ARD: {
       const { reload } = await import("./ard/reload");
       const instance = await reload(account);

src/services/reservation-history.ts

@@ -15,6 +15,10 @@ export const reservationHistoryFromExternal = async (account: ExternalAccount):
       const { history: getHistory } = await import("./izly/history");
       return getHistory(account);
     }
+    case AccountService.Alise: {
+      const { getHistory } = await import("./alise/history");
+      return getHistory(account);
+    }
     default: {
       return [];
     }

src/services/shared/Booking.ts

@@ -1,19 +1,15 @@
-import { ARDAccount, TurboselfAccount } from "@/stores/account/types";
+import { AliseAccount, ARDAccount, TurboselfAccount } from "@/stores/account/types";
 
 export interface BookingTerminal {
   id: string;
-  week: number;
-  from: Date;
-  to: Date;
   terminalLabel: string;
   days: BookingDay[];
-  account: TurboselfAccount | ARDAccount;
+  account: TurboselfAccount | ARDAccount | AliseAccount;
 }
 
 export interface BookingDay {
   id: string;
   canBook: boolean;
-  date: Date;
-  message: string;
+  date?: Date;
   booked: boolean;
 }