Implémentation de TurboSelf

package.json

@@ -87,7 +87,7 @@
     "reanimated-color-picker": "^3.0.4",
     "scolengo-api": "^3.0.5",
     "text-encoding": "^0.7.0",
-    "turbawself": "^1.1.1",
+    "turboself-api": "^2.0.2",
     "zustand": "^4.5.2"
   },
   "devDependencies": {

src/components/Restaurant/RestaurantCard.tsx

@@ -45,7 +45,7 @@ const RestaurantCard: React.FC<RestaurantCardProps> = ({ solde, repas }) => {
             fontSize: 30,
           }}
         >
-          {solde} €
+          {solde.toFixed(2)} €
         </Text>
       </View>
 
@@ -71,7 +71,7 @@ const RestaurantCard: React.FC<RestaurantCardProps> = ({ solde, repas }) => {
             fontSize: 30,
           }}
         >
-          {repas} €
+          {repas}
         </Text>
       </View>
     </View>

src/router/helpers/types.ts

@@ -2,6 +2,7 @@ import { AddonPlacementManifest } from "@/addons/types";
 import type { Chat } from "@/services/shared/Chat";
 import type { Grade } from "@/services/shared/Grade";
 import { Homework } from "@/services/shared/Homework";
+import { ReservationHistory } from "@/services/shared/ReservationHistory";
 import type { AccountService } from "@/stores/account/types";
 import { Log } from "@/utils/logger/logger";
 import type { CurrentPosition } from "@/utils/native/location";
@@ -112,8 +113,12 @@ export type RouteParameters = {
   SettingsDonorsList: undefined;
 
   Menu?: undefined;
-  RestaurantQrCode: undefined;
-  RestaurantHistory: undefined;
+  RestaurantQrCode: {
+    QrCodes: number[]
+  };
+  RestaurantHistory: {
+    histories: ReservationHistory[]
+  };
 
   Messages: undefined;
   ChatCreate: undefined;

src/router/screens/account/index.tsx

@@ -49,7 +49,7 @@ export const screens = [
     tabBarLabel: "Messages",
     tabBarLottie: require("@/../assets/lottie/tab_chat.json"),
   }),
-  createScreen("Menu", PlaceholderScreen, {
+  createScreen("Menu", Menu, {
     headerTitle: "Cantine",
     tabBarLabel: "Cantine",
     tabBarLottie: require("@/../assets/lottie/tab_pizza.json"),

src/services/balance.ts

@@ -6,11 +6,14 @@ export const balanceFromExternal = async (account: ExternalAccount): Promise<Bal
     case AccountService.Turboself: {
       const { getBalance } = await import("./turboself/balance");
       const balance = await getBalance(account);
-      return [balance];
+      return balance;
     }
     case AccountService.ARD: {
       const { balance } = await import("./ard/balance");
       return balance(account);
     }
+    default: {
+      return [];
+    }
   }
 };

src/services/booking.ts

@@ -0,0 +1,34 @@
+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[]> => {
+  switch (account.service) {
+    case AccountService.Turboself: {
+      const { getBookingWeek } = await import("./turboself/booking");
+      const bookings = await getBookingWeek(account, weekNumber);
+      console.log(weekNumber);
+      console.log(bookings[0].days[0].booked);
+      return bookings;
+    }
+    case AccountService.ARD: {
+      // TODO: Implement ARD
+      return [];
+    }
+    default: {
+      return [];
+    }
+  }
+};
+
+export const bookDayFromExternal = async (account: ExternalAccount, id: string, date: Date, booked: boolean): Promise<BookingDay | null> => {
+  switch (account.service) {
+    case AccountService.Turboself: {
+      const { bookDay } = await import("./turboself/booking");
+      const bookedDay = await bookDay(account, id, date, booked);
+      return bookedDay;
+    }
+    case AccountService.ARD: {
+      return null;
+    }
+  }
+};

src/services/menu.ts

@@ -0,0 +1,15 @@
+import { type Account, AccountService } from "@/stores/account/types";
+import { Menu } from "pawnote";
+
+export async function getMenu <T extends Account> (account: Account, date: Date): Promise<Menu> {
+  switch (account.service) {
+    case AccountService.Pronote: {
+      const { getMenu } = await import("./pronote/menu");
+      const menu = await getMenu(account, date);
+      return menu;
+    }
+    default: {
+      throw new Error("Service not implemented.");
+    }
+  }
+}

src/services/pronote/menu.ts

@@ -0,0 +1,21 @@
+import { PronoteAccount } from "@/stores/account/types";
+import { ErrorServiceUnauthenticated } from "../shared/errors";
+import pronote, { Menu } from "pawnote";
+
+export const getMenu = async (account: PronoteAccount, date: Date): Promise<Menu> => {
+  if (!account.instance) {
+    throw new ErrorServiceUnauthenticated("pronote");
+  }
+
+  const menu = await pronote.menus(account.instance, date);
+  if (!menu.days || menu.days.length === 0) {
+    return { date };
+  }
+  const day = menu.days[0];
+
+  if (day.date?.getTime() !== date.getTime()) {
+    return { date };
+  }
+
+  return day;
+};

src/services/qrcode.ts

@@ -0,0 +1,19 @@
+import { AccountService, type ExternalAccount } from "@/stores/account/types";
+import type { Balance } from "./shared/Balance";
+
+export const qrcodeFromExternal = async (account: ExternalAccount): Promise<number> => {
+  switch (account.service) {
+    case AccountService.Turboself: {
+      const { getQRCode } = await import("./turboself/qrcode");
+      const QRCode = await getQRCode(account);
+      return QRCode;
+    }
+    case AccountService.ARD: {
+      // TODO: Implement ARD
+      return 0;
+    }
+    default: {
+      return 0;
+    }
+  }
+};

src/services/reload-account.ts

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

src/services/reservation-history.ts

@@ -11,5 +11,8 @@ export const reservationHistoryFromExternal = async (account: ExternalAccount):
       const { history: getHistory } = await import("./ard/history");
       return getHistory(account);
     }
+    default: {
+      return [];
+    }
   }
 };

src/services/shared/Booking.ts

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

src/services/shared/ReservationHistory.ts

@@ -2,4 +2,5 @@ export interface ReservationHistory {
   amount: number
   timestamp: number
   currency: string
+  label: string
 }

src/services/turboself/balance.ts

@@ -1,17 +1,18 @@
 import type { TurboselfAccount } from "@/stores/account/types";
-import { balance, host } from "turbawself";
 import type { Balance } from "../shared/Balance";
 
-export const getBalance = async (account: TurboselfAccount): Promise<Balance> => {
-  const b = await balance(account.authentication.auth, account.authentication.session);
-  const h = await host(account.authentication.auth, account.authentication.session);
+export const getBalance = async (account: TurboselfAccount): Promise<Balance[]> => {
+  const balances = await account.authentication.session.balances;
+  const currencySymbol = await account.authentication.session.establishment?.currencySymbol;
+  const lunchPrice = await account.authentication.session.host?.lunchPrice;
 
-  return {
-    amount: b.amount / 100,
-    currency: "€",
-    remaining: Math.floor(b.amount / h.lunchPrice)
-
-    // since turboself is french, we can assume the currency is always euro.
-    // note: would need more information to be sure.
-  };
+  const result: Balance[] = [];
+  for (const balance of balances ?? []) {
+    result.push({
+      amount: balance.estimatedAmount / 100,
+      currency: currencySymbol ?? "€",
+      remaining: Math.floor(balance.estimatedAmount / (lunchPrice ?? 0)),
+    });
+  }
+  return result;
 };

src/services/turboself/booking.ts

@@ -0,0 +1,34 @@
+import type { TurboselfAccount } from "@/stores/account/types";
+import type { BookingDay, BookingTerminal } from "../shared/Booking";
+
+export const getBookingWeek = async (account: TurboselfAccount, weekNumber?: number): Promise<BookingTerminal[]> => {
+  const bookings = await account.authentication.session.getBookings(weekNumber);
+
+  return bookings.map((booking) => ({
+    account,
+    id: booking.id,
+    week: booking.week,
+    from: booking.from,
+    to: booking.to,
+    terminalLabel: booking.terminal.name,
+    days: booking.days.map((day) => ({
+      id: day.id,
+      canBook: day.canBook,
+      date: day.date,
+      message: day.message,
+      booked: day.booked,
+    })),
+  }));
+};
+
+export const bookDay = async (account: TurboselfAccount, id: string, date: Date, booked: boolean): Promise<BookingDay> => {
+  const bookedDay = await account.authentication.session.bookMeal(id, date.getDay() + 1, booked ? 1 : 0);
+  console.log(bookedDay);
+  return {
+    id: bookedDay.id,
+    canBook: bookedDay.canBook,
+    date: bookedDay.date,
+    message: bookedDay.message,
+    booked: bookedDay.booked,
+  };
+};

src/services/turboself/history.ts

@@ -1,13 +1,13 @@
 import type { TurboselfAccount } from "@/stores/account/types";
 import type { ReservationHistory } from "../shared/ReservationHistory";
-import { summary } from "turbawself";
 
 export const getHistory = async (account: TurboselfAccount): Promise<ReservationHistory[]> => {
-  const h = await summary(account.authentication.auth, account.authentication.session);
+  const history = await account.authentication.session.getHistory();
 
-  return (h.history ?? []).map((reservation) => ({
+  return (history ?? []).map((reservation) => ({
     timestamp: reservation.date.getTime(),
     amount: reservation.amount / 100,
-    currency: "€"
+    currency: account.authentication.session.establishment?.currencySymbol ?? "€",
+    label: reservation.label,
   }));
 };

src/services/turboself/qrcode.ts

@@ -0,0 +1,6 @@
+import type { TurboselfAccount } from "@/stores/account/types";
+
+export const getQRCode = async (account: TurboselfAccount): Promise<number> => {
+  const cardNumber = await account.authentication.session.host?.cardNumber;
+  return cardNumber ?? 0;
+};

src/services/turboself/reload.ts

@@ -1,8 +1,8 @@
 import type { TurboselfAccount } from "@/stores/account/types";
-import { login } from "turbawself";
+import { authenticateWithCredentials } from "turboself-api";
 
-export const reload = async (account: TurboselfAccount): Promise<TurboselfAccount["authentication"]["auth"]> => {
-  const auth = { ...account.authentication.auth }; // make sure to make a copy of the object.
-  await login(auth);
-  return auth;
+export const reload = async (account: TurboselfAccount): Promise<TurboselfAccount["authentication"]["session"]> => {
+  const auth = { ...account.authentication };
+  const session = await authenticateWithCredentials(auth.username, auth.password);
+  return session;
 };

src/stores/account/types.ts

@@ -1,7 +1,7 @@
 import type pronote from "pawnote";
 import type { Account as PawdirecteAccount, Session as PawdirecteSession } from "pawdirecte";
-import type { Session as TSSession, Authentication as TSAuthentication } from "turbawself";
-import type { Client as ARDClient } from "pawrd";
+import type { Client as ARDClient, Client as PawrdClient } from "pawrd";
+import { Client as TurboselfClient } from "turboself-api";
 import type ScolengoAPI from "scolengo-api";
 import { SkolengoAuthConfig } from "@/services/skolengo/skolengo-types";
 import { User as ScolengoAPIUser } from "scolengo-api/types/models/Common";
@@ -143,8 +143,9 @@ export interface TurboselfAccount extends BaseExternalAccount {
   service: AccountService.Turboself
   instance: undefined
   authentication: {
-    auth: TSAuthentication
-    session: TSSession
+    session: TurboselfClient
+    username: string
+    password: string
   }
 }