@olea-bps/base 1.0.0

package/context/context-connectivity/index.js

@@ -0,0 +1,85 @@
+/**
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import React, { createContext, useState, useEffect, useContext } from "react";
+import NetInfo from "@react-native-community/netinfo";
+
+export const ConnectivityContext = createContext();
+
+export function ConnectivityContextProvider({ children }) {
+  let [networkState, setNetworkState] = useState({
+    isConnected: true,
+    isInternetReachable: true,
+  });
+
+  useEffect(() => {
+    const fetchInitialState = async () => {
+      const state = await NetInfo.fetch();
+      setNetworkState({
+        isConnected: state.isConnected,
+        isInternetReachable: state.isInternetReachable,
+      });
+    };
+
+    fetchInitialState();
+
+    const unsubscribe = NetInfo.addEventListener((state) => {
+      setNetworkState({
+        isConnected: state.isConnected,
+        isInternetReachable: state.isInternetReachable,
+      });
+    });
+
+    return () => unsubscribe();
+  }, []);
+
+  return (
+    <ConnectivityContext.Provider value={networkState}>
+      {children}
+    </ConnectivityContext.Provider>
+  );
+}
+
+/**
+ * Hook, der den Connectivity-Kontext verwendet.
+ * @returns {ConnectivityContext} Der Connectivity-Kontext.
+ * @returns {boolean} Der Connectivity-Kontext.isConnected.
+ * @returns {boolean} Der Connectivity-Kontext.isInternetReachable.
+ * @example
+ * import { useConnectivityContext } from '@olea-bps/context-connectivity';
+ *
+ * function MyComponent() {
+ *    const { isConnected, isInternetReachable } = useConnectivityContext();
+ * }
+ */
+export function useConnectivityContext() {
+  return useContext(ConnectivityContext);
+}
+
+/**
+ * Hook, der die Netzwerkstatuswerte in einem Array bereitstellt.
+ * @returns {Array} Ein Array mit den Netzwerkstatuswerten.
+ * @returns {boolean} return[0] - Gibt an, ob das Gerät mit dem Netzwerk verbunden ist.
+ * @returns {boolean} return[1] - Gibt an, ob das Internet erreichbar ist.
+ * @example
+ * import { useNetInfo } from '@olea-bps/context-connectivity';
+ *
+ * function MyComponent() {
+ *    const [isConnected, isInternetReachable] = useNetInfo();
+ * }
+ */
+export function useNetInfo() {
+  const { isConnected, isInternetReachable } = useContext(ConnectivityContext);
+  return [isConnected, isInternetReachable];
+}

package/context/context-event/AsistServerClient.js

@@ -0,0 +1,82 @@
+/**
+ * Client to get Events from ASiST server
+ */
+export default class AsistServerClient {
+    /**
+     * Base URL which is expanded to generate the request URLs.
+     * @private
+     */
+    #baseUrl
+
+    /**
+     * University code which is communicated to the ASiST server via the request URL in order to retrieve the events of the correct university.
+     * @private
+     */
+    #university
+
+    /**
+     * Returns the request URL to get all events from the ASiST server.
+     * @returns {URL}
+     */
+    // If available implement as private get property
+    getAllUrl() {
+        return new URL(`${this.#baseUrl}/${this.#university}/events`);
+    }
+
+    /**
+     * Construct a ASiST server rest api client.
+     * @param {String} baseUrl URL which is used as the basis for the query URLs.
+     * @param {String} university University code of the university to be queried.
+     */
+    constructor(baseUrl, university) {
+        this.#baseUrl = baseUrl;
+        this.#university = university;
+    }
+
+    /**
+     * Returns a list of all events from the queried university.
+     * @returns {Array} Array of all event objects
+     */
+    getAll() {
+        const getAllEventsURL = this.getAllUrl();
+
+        console.debug(`Get all events: ${getAllEventsURL}`)
+
+        return fetch(
+            getAllEventsURL,
+            {
+                'headers': AsistServerClient.generateHeaders(),
+            }
+        ).then(allEventResponse => allEventResponse.json())
+    }
+
+    /**
+     * Return list of events for the personal code.
+     * @param {String} personalCode Personal code for market events
+     * @returns {Array}
+     */
+    getByPersonalCode(personalCode) {
+        // If available implement query parameter with 'searchParams.set': personalEventsURL.searchParams.set('code', personalCode);
+        const personalEventsURL = `${this.getAllUrl()}?code=${personalCode}`;
+
+        console.debug(`Get personal events: ${personalEventsURL}`)
+
+        return fetch(
+            personalEventsURL,
+            {
+                'headers': AsistServerClient.generateHeaders(),
+            }
+        ).then(personalEventResponse => personalEventResponse.json())
+    }
+
+    /**
+     * Returns standart headers für asist server requests.
+     * @returns {object}
+     */
+    // If available implement as private
+    static generateHeaders() {
+        return {
+            'Accept': 'application/json',
+        }
+    }
+}

package/context/context-event/index.js

@@ -0,0 +1,205 @@
+import {
+    useContext,
+    createContext,
+    useMemo,
+    useCallback,
+    useEffect
+} from 'react';
+
+import { useTheme } from 'react-native-paper';
+
+import { DateTime } from 'luxon';
+
+import { useSecureStoredState } from '../../libraries/stored-state';
+
+import AsistServerClient from './AsistServerClient';
+
+const EventCodeStoreKey = 'event.eventCode';
+const EventsStoreKey = 'event.events';
+const PersonalEventsStoreKey = 'event.personelEvents';
+
+/**
+ * Context for event api
+ */
+export const EventContext = createContext(null);
+
+/**
+ * Extendet context provider for EventAPIContext.
+ * Use settings in Settings.js to generate context values and event api client.
+ * currently only supports event api client for asist server rest api.
+ * But can be extendet to support more event services.
+ * @param {props} properties of provider
+ */
+export default function EventContextProvider({ children }) {
+    const { appSettings } = useTheme();
+    const eventAPIProvider = appSettings?.modules?.event?.api?.provider;
+    const eventAPIBaseUrl = appSettings?.modules?.event?.api?.baseUrl;
+    const university = appSettings?.api?.university ?? null;
+
+    const [events, setEvents] = useSecureStoredState(EventsStoreKey);
+    const [personalEventsCode, setPersonalEventsCode, deletePersonalEventsCode] = useSecureStoredState(EventCodeStoreKey, null, true);
+    const [personalEvents, setPersonalEvents, deletePersonalEvents] = useSecureStoredState(PersonalEventsStoreKey,)
+
+    const sortedEvents = useMemo(
+        () => {
+            // Sortiren der Events wenn welche vorhanden sind
+            if (Array.isArray(events)) {
+                // Kopieren der vorhanden Events, damit neues Array entsteht und reactivität gewahrt wird
+                const sortingEvents = [...events];
+
+                // Die Events werden zuerst nach der Endzeit sortiert und danach nach der Startzeit
+                // Somit werden dem Nutzer die Events nach Startzeit angezeigt
+                // Haben Events die selbe Startzeit, werden diese sortiert nach Endzeit dargstellt
+                sortingEvents
+                    // Soriterung nach Endzeit
+                    .sort((first, second) => DateTime.fromISO(first.end) - DateTime.fromISO(second.end))
+                    // Sortierung nach Startzeit
+                    .sort((first, second) => DateTime.fromISO(first.begin) - DateTime.fromISO(second.begin));
+
+                return sortingEvents;
+            } else {
+                return null;
+            }
+        },
+        [events]
+    )
+
+    const eventAPIClient = useMemo(
+
+        () => {
+            switch (eventAPIProvider?.toLowerCase()) {
+                case 'asist-server':
+                    return new AsistServerClient(eventAPIBaseUrl, university);
+                default:
+                    return null;
+            }
+        },
+        [eventAPIProvider, eventAPIBaseUrl, university]
+    )
+
+    const refreshEvents = useCallback(
+        () => eventAPIClient.getAll()
+            .then(setEvents),
+        [eventAPIClient]
+    )
+
+    const refreshPersonalEvents = useCallback(
+        () => eventAPIClient.getByPersonalCode(personalEventsCode)
+            .then(setPersonalEvents),
+        [eventAPIClient, personalEventsCode]
+    )
+
+    function deletePersonalEventsCodeAndPersonalEvents() {
+        deletePersonalEventsCode();
+        deletePersonalEvents();
+    }
+
+    useEffect(
+        () => {
+            refreshEvents();
+        },
+        [refreshEvents]
+    )
+
+    useEffect(
+        () => {
+            if (personalEventsCode) {
+                refreshPersonalEvents();
+            }
+        },
+        [eventAPIClient, personalEventsCode, refreshPersonalEvents]
+    )
+
+    return (
+        <EventContext.Provider
+            value={
+                {
+                    events: sortedEvents,
+                    refreshEvents: refreshEvents,
+
+                    personalEvents: personalEvents,
+                    refreshPersonalEvents: refreshPersonalEvents,
+
+                    personalEventsCode: personalEventsCode,
+                    setPersonalEventsCode: setPersonalEventsCode,
+                    deletePersonalEventsCode: deletePersonalEventsCodeAndPersonalEvents,
+
+                    apiClient: eventAPIClient,
+                }
+            }
+        >
+            {children}
+        </EventContext.Provider>
+    )
+}
+
+/**
+ * Dieser Hook stellt den EventContext bereit.
+ *
+ * Dieser Hook sollte grundsätlich nur von anderen Hooks verwendet werden.
+ * @returns {object} Eventkontext
+ */
+export function useEventContext() {
+    const context = useContext(EventContext);
+    if (context === null) {
+        throw new Error('useEventContext must be used within an EventContextProvider');
+    }
+    return context;
+}
+
+/**
+ * Über diesen Hook gelangt man an die persönlichen Veranstaltungen.
+ * Dafür wird der persönliche Veranstaltungscode (siehe {@link usePersonalEventsCode }) verwendet.
+ *
+ * @returns {[Array, () => Promise]} Liste der persönlichen Veranstalltungen entsprechnd des persönlichen Codes
+ * @example
+ * const [personalEvents, refreshPersonalEvents] = usePersonalEvents();
+ */
+export function usePersonalEvents() {
+    const eventContext = useEventContext();
+
+    return [eventContext.personalEvents, eventContext.refreshPersonalEvents];
+}
+
+/**
+ *
+ * @returns {[Array, () => void]}
+ * @example
+ * const [events, refreshEvents] = useEvents();
+ *
+ * useEffect(
+ *     () => {
+ *         refreshEvents();
+ *     },
+ *     []
+ * );
+ *
+ * return (
+ *     events.map(
+ *         event => JSON.stringify(event);
+ *     )
+ * )
+ */
+export function useEvents() {
+    const eventContext = useEventContext();
+    return [eventContext.events, eventContext.refreshEvents];
+}
+
+/**
+ * Hook to get and set personal code.
+ * Please use hook like: const [personalCode, setPersonalCode] = usePersonalCode();
+ * currently not in use.
+ * @returns {[string, () => void, () => void]} First element is the value of the personal code and the second element a update function for the personal code.
+ */
+export function usePersonalEventsCode() {
+    const eventContext = useEventContext();
+    return [eventContext.personalEventsCode, eventContext.setPersonalEventsCode, eventContext.deletePersonalEventsCode];
+}
+
+/**
+ * Hook to get event api client from context.
+ * @returns {Object}
+ */
+export function useEventApiClient() {
+    return useEventContext().apiClient;
+}

package/context/context-flex-menu/CollectorVersion2ApiProvider.js

@@ -0,0 +1,32 @@
+import HttpApiProvider, { JsonContentType } from '../../libraries/base-api-provider'
+
+export default class CollectorVersion2ApiProvider extends HttpApiProvider {
+
+    constructor(baseUrl, acceptingLanguages) {
+        // ContentTypes wird auf JSON festgesetzt, da die Kollektoren nur JSON sprechen.
+        super(baseUrl, acceptingLanguages, [JsonContentType]);
+    }
+
+    getMenuEntriesUrl() {
+        return this.extendBaseUrl(['app-menu-entries']);
+    }
+
+    getMenuEntries() {
+        const getUrl = this.getMenuEntriesUrl();
+
+        return this.get(getUrl)
+            .then(response => response.json());
+    }
+
+    /**
+     * Creates a CollektorVersion2ApiProvider instance initialised to a list of standard languages, where the mainLanguage parameter specifies the mainLanguage.
+     * @param {string} baseUrl URL which is used as the basis for the query URLs.
+     * @param {string} mainLanguage Main language which is prioritised.
+     * @returns {CollektorVersion2ApiProvider} Created CollectorVersion2ApiProvider instance.
+     */
+    static from(baseUrl, mainLanguage = 'de') {
+        const acceptingLanguages = CollectorVersion2ApiProvider.languagesFromMainLanguages(mainLanguage);
+
+        return new CollectorVersion2ApiProvider(baseUrl, acceptingLanguages);
+    }
+}

package/context/context-flex-menu/index.js

@@ -0,0 +1,160 @@
+import { createContext, useState, useEffect, useContext, useMemo, useCallback } from 'react'
+
+import { useTheme } from 'react-native-paper';
+import AsyncStorage from '@react-native-async-storage/async-storage';
+
+import { useStagingServer } from '../../libraries/core';
+
+import CollectorVersion2ApiProvider from './CollectorVersion2ApiProvider'
+
+const AsistServerProviderName = 'asist-server';
+const CollectorVersion2ProviderName = 'hs-collector-v2';
+
+const MenuEntriesStoreKey = 'flexMenu.menuEnries';
+
+/**
+ * @typedef {Object} MenuEntry
+ * @property {string} id Id des Menüeintrages
+ * @property {string[]} subMenuEntries Liste der IDs der Untermenüeinträge
+ * @property {string} parentMenuEntry ID des Elternmenüeintrages
+ * @property {string} openIn `webbrowser` wenn die URL im Browser geöffent werden soll. `webview` wenn die URL in einer Webview geöffent werden soll.
+ * @property {string} type - Falls dieser Menüeintrag ein Hauptmenüeintrag ist, ist hier der zugeötige Tab anzugeben
+ * @property {string} language Sprache des Menüeintrages. Die möglichen Werte sind in der Settings.js in der Sprachenliste als `extCode` zu finden
+ * @property {string} title Titel des Menüeintrages
+ * @property {string} description Beschreibung
+ * @property {string} url URL des Menüeintrages. Wie diese URL geöffnet wird, wird über {@link openIn } geregelt
+ * @property {string} icon Name des anzuzeigenen Icons
+ * @property {string} image URL des Anzuziegenden Bildes
+ */
+
+export const FlexMenuContext = createContext({
+    menuEntries: [],
+});
+
+function FlexMenuContextProvider({ children }) {
+    const componentName = FlexMenuContextProvider.name;
+    const theme = useTheme();
+    const isStagingServerActive = useStagingServer();
+
+    // Einstellungen für das InfoDialog-Moduls
+    const flexMenuSettings = theme?.appSettings?.modules?.flexmenu;
+    // Einstellungen für die API-Provider
+    const flexMenuApiSettings = flexMenuSettings?.api;
+    // Soll der Staging-Provider verwendet werden?
+    const flexMenuApiProviderSettings = isStagingServerActive
+        // Wenn ja, werden die Staging Provider-Einstellungen geladen
+        ? flexMenuApiSettings?.staging
+        // Wenn nein, werden die productiven Provider-Einstellungen geladen
+        : flexMenuApiSettings?.production;
+    // Basis URL der API
+    const flexMenuApiBaseUrl = flexMenuApiProviderSettings?.url;
+    // API-Provider
+    const flexMenuApiProvider = flexMenuApiProviderSettings?.provider;
+
+    const [menuEntries, setMenuEntries] = useState(null);
+
+    // Estellen des API-Providers bzw. erneuern wenn sich Einstellungen ändern.
+    const apiProvider = useMemo(
+        () => {
+            switch (flexMenuApiProvider?.toLowerCase()) {
+                //case AsistServerProviderName:
+                //    return new AsistServerApiProvider.from(timetableApiBaseUrl, timetableApiUniversity, 'de');
+                //    break;
+                case CollectorVersion2ProviderName:
+                    return new CollectorVersion2ApiProvider.from(flexMenuApiBaseUrl);
+                    break;
+                default:
+                    console.log(`${componentName}: Can't build api provider: ${flexMenuApiProvider}`)
+                    return null;
+            }
+        },
+        [flexMenuApiProvider, flexMenuApiBaseUrl]
+    );
+
+    const refreshMenuEntries = useCallback(
+        () =>
+            apiProvider?.getMenuEntries()
+                .then(setMenuEntries)
+                .catch(reason => console.error(componentName, ':', 'Error while updating menu entries', ':', reason)),
+        [apiProvider, setMenuEntries]
+    );
+
+    // Aktualiseren des menuEntries-States
+    useEffect(
+        () => {
+            refreshMenuEntries();
+        },
+        [refreshMenuEntries]
+    );
+
+    // Speichert die geänderten Menüpunkte in den Store
+    useEffect(
+        () => {
+            if (menuEntries) {
+                AsyncStorage.setItem(MenuEntriesStoreKey, JSON.stringify(menuEntries))
+                    .catch(reason => console.error(`${componentName}: Error while safing courses in store: ${reason}`));
+            }
+        },
+        [menuEntries]
+    );
+
+    return (
+        <FlexMenuContext.Provider
+            value={{
+                menuEntries,
+                refreshMenuEntries,
+            }}
+        >
+            {children}
+        </FlexMenuContext.Provider>
+    )
+
+}
+
+function useFlexMenuContext() {
+    return useContext(FlexMenuContext);
+}
+
+function useMenuEntries() {
+    const { menuEntries, refreshMenuEntries } = useFlexMenuContext();
+
+    return [
+        Array.isArray(menuEntries)
+            ? menuEntries
+            : [],
+        refreshMenuEntries
+    ];
+}
+
+function useChildMenuEntries(parentMenuId) {
+    const [menuEntries, refreshMenuEntries] = useMenuEntries();
+
+    // Alle Menüeinträge nach der parentMenuId filtern
+    const childMenuEntries = menuEntries.filter(
+        // Die Eltern-ID des zu filternden Menüeintrages wird in die Pfad-Segmente zerlegt und das letzte Segment zum vergleichen genommen.
+        // Falls Eltern-ID im zu filternden Menüeintrages nicht vorhanden, wird null als Ersatzwert verwendet.
+        menuEntry => parentMenuId === (menuEntry?.parentMenuEntry?.split?.('/')?.filter?.(urlSegment => urlSegment !== '')?.pop?.() ?? null)
+    );
+
+    return [childMenuEntries, refreshMenuEntries]
+}
+
+/**
+ * Es werden alle Hauptmenüeinträge zurückgegeben, wobei Menueinträge ohne Eltern-ID sind Hauptmenüeinträge
+ * @returns {[MenuEntry[], () => void]}
+ * @example
+ * const [mainMenuEntries, refreshMenuEntries] = useMainMenuEntries();
+ */
+function useMainMenuEntries() {
+    // Menueinträge ohne Eltern-ID sind Hauptmenüeinträge
+    return useChildMenuEntries(null);
+}
+
+export {
+    FlexMenuContext as default,
+    FlexMenuContextProvider,
+    useFlexMenuContext,
+    useMenuEntries,
+    useChildMenuEntries,
+    useMainMenuEntries,
+}

package/context/context-info-dialog/CollektorVersion2ApiProvider.js

@@ -0,0 +1,53 @@
+import HttpApiProvider from '../../libraries/base-api-provider';
+
+/**
+ * Infos-API-Client für Kollektor
+ */
+export default class CollektorVersion2ApiProvider extends HttpApiProvider {
+
+    /**
+     * @param {string} baseUrl URL des Kollektors
+     * @param {string[]} acceptingLanguages Liste der akzeptierten Sprachen die dem Kollektor mitgesendet werden, dabei ist die Priorität die Reihenfolge.
+     */
+    constructor(baseUrl, acceptingLanguages) {
+        // ContentTypes wird auf JSON festgesetzt, da der Kollektor nur JSON spricht.
+        super(baseUrl, acceptingLanguages, ['application/json']);
+    }
+
+    /**
+     * Erstellt und gibt die abzufragende URL für die Abfrage aller Infos zurück.
+     *
+     * @returns {URL} URL für die Abfrage aller Infos-Objekte.
+     */
+    getInfosUrl() {
+        const getInfoUrl = this.extendBaseUrl(['infos']);
+
+        return getInfoUrl
+    }
+
+    /**
+     * Gibt die Liste aller Info-Objekte zurück.
+     *
+     * @returns {Array} Liste aller Info-Objekte.
+     */
+    getInfos() {
+        const getInfosUrl = this.getInfosUrl();
+
+        return this.get(getInfosUrl)
+            .then(response => response.json());
+    }
+
+    /**
+     * Erstellt eine CollektorVersion2ApiProvider-Instanz, welche Englisch und Deutsch initialisiert wird.
+     * Die priorisierte Hauptsprache kann als Paramter übergeben werden.
+     *
+     * @param {string} baseUrl URL des Kollektors
+     * @param {string} [mainLanguage='de'] Hauptsprache, welche priorisiert wird.
+     * @returns {CollektorVersion2ApiProvider} Erstellte CollektorVersion2ApiProvider-Instanz
+     */
+    static from(baseUrl, mainLanguage = 'de') {
+        const acceptingLanguages = CollektorVersion2ApiProvider.languagesFromMainLanguages(mainLanguage);
+
+        return new CollektorVersion2ApiProvider(baseUrl, acceptingLanguages);
+    }
+}

package/context/context-info-dialog/ProviderErrors.js

@@ -0,0 +1,22 @@
+
+/**
+ * Diese Exception wird ausgelöst, wenn zu dem Studenplancode kein Stundenplan abgeholt werden kann.
+ */
+export class TimetableNotFoundError extends Error {
+
+    /**
+     * Stundenplancode welcher keinem Stundenplan angehörig ist.
+     * @type {string}
+     */
+    timetableCode
+
+    /**
+     *
+     * @param {string} timetableCode Stundenplancode, welcher zu einem Fehler führte, weil dieser mit keinem Stundenplan verknüpft ist
+     */
+    constructor(timetableCode) {
+        super(`Timetable code ${timetableCode} is not linked to a timetable`);
+        this.timetableCode = timetableCode;
+        this.name = this.constructor.name;
+    }
+}