Intégration Skolengo - Installation + Auth

.npmrc

@@ -0,0 +1,2 @@
+omit=optional
+no-optional=true

.yarnrc

@@ -0,0 +1 @@
+--install.ignore-optional true

App.old.tsx

@@ -54,7 +54,6 @@ import HeaderSelectScreen from './views/Settings/HeaderSelectScreen';
 import PaymentScreen from './views/Settings/PaymentScreen';
 
 import GradesScreen from './views/GradesScreenNew';
-import GradeView from './views/Grades/GradeView';
 import GradesSettings from './views/Grades/GradesSettings';
 
 import NewsScreen from './views/NewsScreen';

android/app/src/main/AndroidManifest.xml

@@ -38,6 +38,7 @@
         <category android:name="android.intent.category.DEFAULT"/>
         <category android:name="android.intent.category.BROWSABLE"/>
         <data android:scheme="papillon"/>
+        <data android:scheme="skoapp-prod"/>
         <data android:scheme="xyz.getpapillon.app"/>
         <data android:scheme="exp+papillonvex"/>
       </intent-filter>

app.json

@@ -2,7 +2,7 @@
   "expo": {
     "name": "Papillon",
     "slug": "papillonvex",
-    "scheme": "papillon",
+    "scheme": ["papillon", "skoapp-prod"],
     "version": "6.6.2",
     "orientation": "portrait",
     "icon": "./assets/icon.png",
@@ -14,21 +14,6 @@
     "notification": {
       "icon": "./assets/icon-small-notif.png"
     },
-    "intentFilters": [
-      {
-        "action": "VIEW",
-        "autoVerify": true,
-        "data": [
-          {
-            "scheme": "skoapp-prod"
-          }
-        ],
-        "category": [
-          "BROWSABLE",
-          "DEFAULT"
-        ]
-      }
-    ],
     "splash": {
       "image": "./assets/launch/splash-light.png",
       "resizeMode": "cover",
@@ -38,7 +23,9 @@
       "supportsTablet": true,
       "appStoreUrl": "https://apps.apple.com/us/app/papillon-lappli-scolaire/id6477761165",
       "bundleIdentifier": "xyz.getpapillon.ios",
-      "associatedDomains": ["applinks:getpapillon.xyz"],
+      "associatedDomains": [
+        "applinks:getpapillon.xyz"
+      ],
       "splash": {
         "backgroundColor": "#32AB8E",
         "image": "./assets/launch/splash-light.png",

fetch/Skolengo/SkolengoAuthWorkflow.ts

@@ -0,0 +1,92 @@
+import { School } from 'scolengo-api/types/models/School';
+import { SkolengoDataProvider } from './SkolengoDataProvider';
+import { AppContextType } from '../../utils/AppContext';
+import {
+  AuthRequest,
+  exchangeCodeAsync,
+  resolveDiscoveryAsync,
+} from 'expo-auth-session';
+import { coolDownAsync, warmUpAsync } from 'expo-web-browser';
+import { Alert } from 'react-native';
+import { OID_CLIENT_ID, OID_CLIENT_SECRET, REDIRECT_URI } from 'scolengo-api';
+
+const skolengoErrorHandler = (err?: Error | any) => {
+  if (err instanceof Error) console.error(err);
+  Alert.alert(
+    'Erreur',
+    'Une erreur est survenue lors de la connexion à Skolengo. Veuillez réessayer.'
+  );
+  return null;
+};
+
+export const loginSkolengoWorkflow = async (
+  appContext: AppContextType,
+  navigation: any,
+  school: School,
+  skolengoInstance: SkolengoDataProvider | null = null
+) => {
+  const disco = await Promise.all([
+    fetch(school.emsOIDCWellKnownUrl)
+      .then((res) => res.json())
+      .then((res) => res.issuer),
+    warmUpAsync(),
+  ])
+    .then(([issuer]) => resolveDiscoveryAsync(issuer))
+    .catch(skolengoErrorHandler);
+  if (!disco) return;
+  const authRes = new AuthRequest({
+    clientId: OID_CLIENT_ID,
+    clientSecret: OID_CLIENT_SECRET,
+    redirectUri: REDIRECT_URI,
+    extraParams: {
+      scope: 'openid',
+      response_type: 'code',
+    },
+    usePKCE: false,
+  });
+  const res = await authRes.promptAsync(disco).catch(skolengoErrorHandler)!;
+  coolDownAsync();
+  if (!res || res?.type !== 'success') return;
+  if (!res.params.code) {
+    return skolengoErrorHandler(res.error);
+  }
+  const token = await exchangeCodeAsync(
+    {
+      clientId: OID_CLIENT_ID,
+      clientSecret: OID_CLIENT_SECRET,
+      code: res.params.code,
+      redirectUri: REDIRECT_URI,
+    },
+    disco
+  ).catch(skolengoErrorHandler);
+  if (!token) return skolengoErrorHandler();
+  //console.log({token});
+  Alert.alert(
+    'Skolengo : intégration en cours',
+    'Veuillez patienter, le processus de connexion à Skolengo à fonctionné.\nMais l\'intégration de Skolengo (NG) n\'est pas encode terminé.\n\nRevenez plus tard.'
+  );
+  /* // TODO : Créer l'intégration via scolengo-api
+  return; */
+  /* await Promise.all([
+    AsyncStorage.setItem('service', 'Skolengo'),
+    AsyncStorage.setItem('token', 'skolengo'),
+  ]);
+  showMessage({
+    message: 'Connecté avec succès',
+    type: 'success',
+    icon: 'auto',
+    floating: true,
+  });
+  if (appContext) {
+    const a = new SkolengoDatas(token, school);
+    await a.saveToken(disco);
+    appContext.dataProvider.init('Skolengo').then(() => {
+      appContext.setLoggedIn(true);
+      navigation.popToTop();
+    });
+    return true;
+  }
+  skolengoInstance.school = school;
+  skolengoInstance.rtInstance = token;
+  return skolengoInstance; */
+};

fetch/SkolengoData/SkolengoCache.js → fetch/Skolengo/SkolengoCommonCache.ts

@@ -1,36 +1,50 @@
 import AsyncStorage from '@react-native-async-storage/async-storage';
 
-class SkolengoPrivateCache {
+class CommonCacheUtils {
   static ASYNCSTORAGE_PREFIX = 'SkolengoCache_';
 
   static _DATE_ENCODING_CHAR = '@';
 
-  static validateDateString = (str) =>
+  static validateDateString = (str: string) =>
     typeof str === 'string' &&
     new Date(str?.toString()).toString() !== 'Invalid Date' &&
     str === new Date(str?.toString()).toISOString();
 
-  static parser = (obj) =>
+  static parser = (obj: any) =>
     JSON.stringify(
       obj,
       (_key, value) =>
         this.validateDateString(value)
-          ? `${this.DATE_ENCODING_CHAR}${value}${this.DATE_ENCODING_CHAR}`
+          ? `${this._DATE_ENCODING_CHAR}${value}${this._DATE_ENCODING_CHAR}`
           : value,
       2
     );
 
-  static deparser = (str) =>
+  static deparser = (str: string) =>
     JSON.parse(str, (_key, value) =>
       typeof value === 'string' &&
-      value.startsWith(this.DATE_ENCODING_CHAR) &&
-      value.endsWith(this.DATE_ENCODING_CHAR)
-        ? new Date(value.replaceAll(this.DATE_ENCODING_CHAR, ''))
+      value.startsWith(this._DATE_ENCODING_CHAR) &&
+      value.endsWith(this._DATE_ENCODING_CHAR)
+        ? new Date(value.replaceAll(this._DATE_ENCODING_CHAR, ''))
         : value
     );
 }
 
-export class SkolengoCache {
+type CommonCacheItem<T> =
+  | {
+      expired: true;
+      maxDate: number;
+      data: T;
+    }
+  | {
+      expired: false;
+      maxDate: number;
+      data: T;
+    };
+
+type CommonCacheSetItem<T> = Omit<CommonCacheItem<T>, 'expired'>;
+
+export class SkolengoCommonCache {
   static SECOND = 1000;
 
   static MINUTE = 60 * this.SECOND;
@@ -39,55 +53,76 @@ export class SkolengoCache {
 
   static DAY = 24 * this.HOUR;
 
+  static TIMEZONE_OFFSET = new Date().getTimezoneOffset() * this.MINUTE;
+
   static msToTomorrow() {
     const now = Date.now();
-    const timePassedToday = now % this.DAY;
+    const timePassedToday = (now % this.DAY) + this.TIMEZONE_OFFSET;
     return this.DAY - timePassedToday;
   }
 
-  static setItem(key, value, timeout) {
+  static setItem<T>(key: CacheKeys, value: T, timeout: number) {
     const storedDatas = {
       maxDate: new Date().getTime() + timeout,
       data: value,
     };
     return AsyncStorage.setItem(
-      `${SkolengoPrivateCache.ASYNCSTORAGE_PREFIX}${key}`,
-      SkolengoPrivateCache.parser(storedDatas)
+      `${CommonCacheUtils.ASYNCSTORAGE_PREFIX}${key}`,
+      CommonCacheUtils.parser(storedDatas)
     );
   }
 
-  static async setCollectionItem(key, id = '', value, timeout) {
-    const actualCache = await this.getItem(key, {});
+  static async setCollectionItem<T>(
+    key: CacheKeys,
+    id: string,
+    value: T,
+    timeout: number
+  ) {
     if (id?.toString().trim().length === 0) return;
-    actualCache.data[id] = { value, maxDate: new Date().getTime() + timeout };
+    const actualCache = await this.getItem<
+      Record<string, CommonCacheSetItem<T>>
+    >(key, {});
+    actualCache.data![id] = {
+      data: value,
+      maxDate: new Date().getTime() + timeout,
+    };
     return this.setItem(key, actualCache.data, this.DAY * 30);
   }
 
-  static async getItem(key, defaultResponse = null) {
+  static async getItem<T = null>(
+    key: CacheKeys,
+    defaultResponse?: T
+  ): Promise<CommonCacheItem<T>> {
     const cachedDatas = await AsyncStorage.getItem(
-      `${SkolengoPrivateCache.ASYNCSTORAGE_PREFIX}${key}`
+      `${CommonCacheUtils.ASYNCSTORAGE_PREFIX}${key}`
     );
     if (cachedDatas === null)
       return {
         expired: true,
         maxDate: 0,
-        data: defaultResponse,
+        data: defaultResponse || (null as T),
       };
-    const value = SkolengoPrivateCache.deparser(cachedDatas);
+    const value = CommonCacheUtils.deparser(cachedDatas);
     return {
       expired: value.maxDate < new Date().getTime(),
       maxDate: value.maxDate,
       data: value.data,
     };
   }
 
-  static async getCollectionItem(key, id, defaultResponse = null) {
-    const cachedDatas = await this.getItem(key, {});
+  static async getCollectionItem<T = null>(
+    key: CacheKeys,
+    id: string,
+    defaultResponse?: T
+  ) {
+    const cachedDatas = await this.getItem<
+      Record<string, CommonCacheSetItem<T>>
+    >(key, {});
     if (!cachedDatas?.data || !cachedDatas?.data[id])
       return {
         expired: true,
         maxDate: 0,
-        data: defaultResponse,
+        data: defaultResponse || (null as T),
       };
     const value = cachedDatas.data[id];
     return {
@@ -97,9 +132,9 @@ export class SkolengoCache {
     };
   }
 
-  static removeItem(key) {
+  static removeItem(key: CacheKeys) {
     return AsyncStorage.removeItem(
-      `${SkolengoPrivateCache.ASYNCSTORAGE_PREFIX}${key}`
+      `${CommonCacheUtils.ASYNCSTORAGE_PREFIX}${key}`
     );
   }
 
@@ -120,5 +155,9 @@ export class SkolengoCache {
     homeworkList: 'homeworkList',
     timetable: 'timetable',
     recap: 'recap',
-  };
+  } as const;
 }
+
+type _CacheKeys = typeof SkolengoCommonCache.cacheKeys;
+
+export type CacheKeys = _CacheKeys[keyof _CacheKeys];

fetch/Skolengo/SkolengoDataProvider.ts

@@ -0,0 +1,9 @@
+let SkolengoNotImplementedWarn = false;
+export class SkolengoDataProvider {
+  constructor() {
+    if (!SkolengoNotImplementedWarn) {
+      console.warn('SkolengoDataProvider is not implemented');
+      SkolengoNotImplementedWarn = true;
+    }
+  }
+}