@olea-bps/base 1.0.0

package/libraries/icons-openasist/index.js

@@ -0,0 +1,143 @@
+/**
+ * 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 from 'react';
+
+import { useTheme } from "react-native-paper";
+import createIconSet from '@expo/vector-icons/createIconSet';
+import PropTypes from "prop-types";
+import { SvgCssUri } from 'react-native-svg';
+const glyphMap = {
+    "bus":                      "a",
+    "train":                    "b",
+    "close":                    "c",
+    "messages":                 "d",
+    "menu":                     "e",
+    "grid":                     "f",
+    "more-horizontal":          "g",
+    "more-vertical":            "h",
+    "paperplane-outline":       "i",
+    "partlysunny":              "j",
+    "partlysunny-outline":      "k",
+    "rainy":                    "l",
+    "rainy-outline":            "m",
+    "thunderstorm":             "n",
+    "thunderstorm-outline":     "o",
+    "sunny":                    "p",
+    "sunny-outline":            "q",
+    "down":                     "r",
+    "download":                 "s",
+    "print":                    "t",
+    "hilfe":                    "u",
+    "back":                     "v",
+    "lock":                     "w",
+    "lock-open":                "x",
+    "navigation":               "y",
+    "forward":                  "z",
+    "profile":                  "A",
+    "opal":                     "B",
+    "mensa":                    "C",
+    "location":                 "D",
+    "inbox":                    "E",
+    "imprint":                  "F",
+    "pts":                      "G",
+    "feedback":                 "H",
+    "book":                     "I",
+    "news":                     "J",
+    "up":                       "K",
+    "tram":                     "L",
+    "rss":                      "M",
+    "map-search":               "N",
+    "m-start1":                 "O",
+    "dashboard":                "P",
+    "timetable":                "Q",
+    "search":                   "R",
+    "settings":                 "S",
+    "coffee":                   "T",
+    "check":                    "V",
+    "star":                     "W",
+    "star-selected":            "X",
+    "edit":                     "Y",
+    "time":                     "A1",
+    "open-external":            "A2",
+    "share":                    "1",
+    "accessibility":            "A3",
+};
+const CustomIcon = createIconSet(glyphMap, 'openasist');
+
+
+/**
+ * Icons of the Openasist app
+ *
+ * This component handles the load of the icon font and
+ * provides a simple way to include these icons.
+ *
+ * Parameters:
+ *  - icon: Name (slug) of the icon
+ *  - size: Size (as Number) of the icon
+ *  - color: Color of the icon
+ *
+ * Navigation-Parameters:
+ *  - none
+ */
+function IconsOpenasist({ icon, iconSVG: IconSVG, size, color, accessibilityLabel, ...props }) {
+    const theme = useTheme();
+    const { AppIcons } = theme;
+
+    const iconSize = size ?? 26;
+    const iconAriaLabel = props?.['aria-label'] ?? accessibilityLabel ?? null;
+    const iconAriaHidden = iconAriaLabel ? false : true;
+
+    const iconProps = {
+        color: color ?? 'black',
+        'aria-hidden': iconAriaHidden,
+        'aria-label': iconAriaLabel,
+    }
+
+    if (IconSVG) {
+        return (
+            <IconSVG
+                {...iconProps}
+                width={iconSize}
+                height={iconSize}
+            />
+        );
+    } else if (AppIcons) {
+        return (
+            <AppIcons
+                {...iconProps}
+                name={icon}
+                size={iconSize}
+            />
+        );
+    } else {
+        return (
+            <CustomIcon
+                {...iconProps}
+                name={icon}
+                size={iconSize}
+            />
+        );
+    }
+}
+
+// propTypes für Funktionen wird in react.js 19 entfernt
+IconsOpenasist.propTypes = {
+    icon: PropTypes.string,
+    iconSVG: PropTypes.func,
+    size: PropTypes.number,
+    color: PropTypes.string
+};
+
+export default IconsOpenasist;

package/libraries/notifications/index.js

@@ -0,0 +1,268 @@
+/**
+ * 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 from 'react';
+import messaging from '@react-native-firebase/messaging';
+
+import notifee, { AndroidStyle, EventType } from '@notifee/react-native';
+import { feedApi, RootNavigation, store, updateFeeds } from '../core';
+import SubscriberService from './services/subscriber.service'
+
+export default class OpenASiSTNotifications {
+    subscriberService = null
+
+    navConfig = null;
+
+    languages = null;
+
+    /**
+     *
+     * @param configuration: Object  (see 'notification' in Settings.js)
+     * @param navigationConfiguration : Object (see 'navigation' in Settings.js)
+     * @param languages : Object (see 'languages' in Settings.js)
+     */
+    constructor(configuration, navigationConfiguration, languages) {
+        this.subscriberService = new SubscriberService(configuration);
+        this.navConfig = navigationConfiguration;
+        this.languages = languages;
+    }
+
+    /**
+     * App is in background, handle incoming messages
+     *
+     * Important: This function must be called as soon as possible! (Before app initialization)
+     */
+    initBackgroundHandler() {
+        messaging().setBackgroundMessageHandler(async remoteMessage => {
+            await this.createNotification(remoteMessage);
+        });
+
+        notifee.onBackgroundEvent(async ({ type, detail }) => {
+            await this.handlePNAction(type, detail);
+        });
+    }
+
+    /**
+     * App is in foreground
+     */
+    initForegroundHandler() {
+        this.requestPermission().then(async () => {
+            await this.subscriberService.initializeSubscriber();
+
+            // Listen for new Messages while the app is in foreground
+            messaging().onMessage(async remoteMessage => {
+                await this.createNotification(remoteMessage);
+            });
+
+            notifee.onForegroundEvent(async ({ type, detail }) => {
+                await this.handlePNAction(type, detail);
+            })
+        });
+    }
+
+    unregister() {
+        // Unregister the user device from firebase
+        messaging().unregisterDeviceForRemoteMessages().then(() => {/* Unregistered */});
+        notifee.cancelAllNotifications().then(() => {/* Cancelled all notifications */});
+    }
+
+    /**
+     * Handle all actions of a push notification, no matter if back- or foreground
+     *
+     * @param type
+     * @param detail
+     * @returns {Promise<void>}
+     */
+    async handlePNAction(type, detail) {
+        // notification details and action (like "mark as seen") the user has pressed
+        const { notification, pressAction } = detail;
+        switch(type) {
+            case EventType.PRESS:
+                const {newsDetail} = this.navConfig;
+                this.subscriberService.markNotificationAsSeen(notification.id);
+                await notifee.cancelNotification(notification.id);
+                RootNavigation.onNavigationReady(() => {
+                    // Trigger News Refresh
+                    store.dispatch( updateFeeds() );
+                    RootNavigation.navigate(newsDetail.screen, newsDetail.params(notification.data.payload));
+                });
+                break;
+            case EventType.APP_BLOCKED:
+            case EventType.DISMISSED:
+                this.subscriberService.markNotificationAsSeen(notification.id);
+                await notifee.cancelNotification(notification.id);
+                break;
+            case EventType.FG_ALREADY_EXIST:
+                await notifee.cancelNotification(notification.id);
+                break;
+            /*
+            case EventType.ACTION_PRESS && pressAction.id === 'mark-as-read':
+                this.subscriberService.markNotificationAsSeen(notification.id)
+                // Remove the notification
+                await notifee.cancelNotification(notification.id);
+                break;
+                */
+        }
+    }
+
+
+    /**
+     * Request permission to display notifications
+     *
+     * @returns {Promise<void>}
+     */
+    async requestPermission() {
+        const authStatus = await notifee.requestPermission({
+            criticalAlert: true
+        });
+
+        const enabled =
+            authStatus === messaging.AuthorizationStatus.AUTHORIZED ||
+            authStatus === messaging.AuthorizationStatus.PROVISIONAL;
+
+        await notifee.requestPermission({
+            criticalAlert: true
+        })
+
+        if (enabled) {
+            console.log('Authorization status:', authStatus);
+        }
+    }
+
+
+    /**
+     * Collect data and create the notification
+     * @returns {Promise<void>}
+     */
+    async createNotification(messageDetails) {
+        const language = store.getState().settingReducer.settingsGeneral.language;
+        const {enabledFeedNotifications, enableAllNotifications, enablePushNotifications} = store.getState().settingReducer.settingsNotifications;
+        if(!enablePushNotifications) return;
+
+        const {notificationId, type, id, fallbackMessage} = messageDetails?.data;
+        const isCritical = type === 'critical';
+
+        let fallbackText = '';
+        try {
+            const fallback = JSON.parse(fallbackMessage);
+            fallbackText = fallback[language];
+        } catch( e) {
+            fallbackText = fallbackMessage;
+        }
+
+        if(type === undefined || id === undefined || id === null || id === "") {
+            return;
+        }
+
+        switch(type) {
+            case 'critical':
+            case 'feed':
+                feedApi.getNewsById(id, news => {
+                    if(news === -1 || (news && !news.title)) {
+                        return;
+                    } else if(news !== 0 && news.title) {
+                        // If not all notifications, feed notification or the explicit feed are enabled, return
+                        if(!enabledFeedNotifications || enabledFeedNotifications?.length === 0 || (enabledFeedNotifications?.length > 0 && enabledFeedNotifications.indexOf(parseInt(news.originFeedId, 10)) === -1)) {
+                            return;
+                        }
+                        this.displayNotification({
+                            id: notificationId,
+                            title: news.title,
+                            desc: news.shortDesc,
+                            image: news.descImageUrl,
+                            isCritical,
+                            payload: news
+                        });
+                    }
+                });
+                break;
+            case 'grades':
+                // TODO -> Network request + display notification
+                break;
+
+            default:
+                return;
+        }
+
+    }
+
+    /**
+     * Show a notification
+     *
+     * @param notification
+     * @returns {Promise<void>}
+     */
+    async displayNotification(notification) {
+        const {id, title, desc, image, isCritical, payload} = notification;
+
+        if(!id) { console.error('Id is required to display a notification'); return; }
+        if(!title) { console.error('Title is required to display a notification'); return; }
+
+
+        // Create a channel (required for Android)
+        const defaultChannelId = await notifee.createChannel({
+            id: 'common',
+            name: 'Allgemeine Benachrichtigungen',
+            sound: 'default'
+        });
+        const criticalChannelId = await notifee.createChannel({
+            id: 'critically',
+            name: 'Kritische Benachrichtigungen',
+            bypassDnd: true,
+            sound: 'default'
+        });
+
+        // Additional Android Settings:
+        let android = {};
+        if(image) {
+            // NOTE: iOS Requires local files: https://notifee.app/react-native/reference/iosnotificationattachment
+            // So this isn't implemented right now.
+            android = {
+                style: { type: AndroidStyle.BIGPICTURE, picture: image}
+            }
+        }
+
+
+        await notifee.displayNotification({
+            id,
+            title,
+
+            // By default notifee supports basic HTML tags and removes unsupported ones, but we need to replace the escaped characters
+            body: desc,
+            data: {
+                notificationId: id,
+                payload
+            },
+            android: {
+                ...android,
+                channelId: isCritical ? criticalChannelId : defaultChannelId,
+                smallIcon: 'notification_icon',
+                //smallIcon: 'name-of-a-small-icon', // optional, defaults to 'ic_launcher'.
+                // pressAction is needed if you want the notification to open the app when pressed
+                pressAction: {
+                    id: 'default',
+                },
+                sound:'default'
+            },
+            ios: isCritical ? {
+                critical: true,
+                //sound: 'critical.wav',
+                // iOS > 12
+                // play at 90% sound volume
+                criticalVolume: 0.9,
+                sound: 'default'
+            } : {sound: 'default'}
+        });
+    }
+}

package/libraries/notifications/services/subscriber.service.js

@@ -0,0 +1,123 @@
+import uuid from 'react-native-uuid';
+import messaging from '@react-native-firebase/messaging';
+import debounce from 'lodash/debounce';
+
+import { store } from '../../core';
+import { POSTOptions } from '../../core/constants/api';
+import { onNotificationsSubscriberUpdate } from '../../core/redux/actions/notifications';
+
+
+export default class SubscriberService {
+    notificationServerUrl = '';
+    universityCode = '';
+    subscriberId = null
+
+    constructor(configuration) {
+        if(!configuration.notificationServerUrl) {
+            throw Error('Missing Notification Server Url');
+        }
+        if(!configuration.universityCode) {
+            throw Error('Missing University Code');
+        }
+
+        this.notificationServerUrl = configuration.notificationServerUrl;
+        this.notificationStgServerUrl = configuration.notificationStgServerUrl;
+        this.universityCode = configuration.universityCode;
+        this.upsertSubscriber = debounce(this.upsertSubscriber, 2000);
+    }
+
+
+    /**
+     * Register a new Subscriber or update the existing one
+     */
+    async initializeSubscriber() {
+        this.subscriberId = this.getSubscriberId();
+        if(!messaging().isDeviceRegisteredForRemoteMessages) {
+            await messaging().registerDeviceForRemoteMessages();
+        }
+        const token = await this.getFCMToken();
+
+        await this.upsertSubscriber(token);
+    }
+
+
+    /**
+     * Return the subscriber id stored in the redux store or create a new ID.
+     *
+     * @returns string subscriberId
+     * @private
+     */
+    getSubscriberId() {
+        let subscriberId = store.getState().notificationsReducer.subscriberId;
+
+        if(subscriberId) {
+            return subscriberId;
+        }
+
+        subscriberId = uuid.v4();
+        store.dispatch(onNotificationsSubscriberUpdate(subscriberId));
+        return subscriberId;
+    }
+
+
+    /**
+     * Get Device Token for Firebase Cloud Messaging
+     *
+     * @returns {Promise<void>}
+     */
+    async getFCMToken() {
+        return await messaging().getToken();
+    }
+
+
+    /**
+     * Register / Update a subscriber (=user) with the current device token
+     *
+     * @returns {Promise<void>}
+     */
+    async upsertSubscriber(token, skipRefresh = false) {
+        const useStaging = store.getState().settingReducer.settingsDevelop.useStaging;
+        const url = useStaging ?  this.notificationStgServerUrl : this.notificationServerUrl
+
+        fetch(
+            `${url}/subscriber?subscriberId=${this.subscriberId}&universityCode=${this.universityCode}&token=${token}&useDev=${useStaging}`,
+            {...POSTOptions})
+            .then((response) => response.json())
+            .then(() => {
+               // subscriber updated
+            })
+            .catch((error) => {
+                console.warn('Error Code: 1100 : ', error);
+            });
+
+        // Listen for Token updates
+        if(!skipRefresh) {
+            messaging().onTokenRefresh(newToken => {
+                this.upsertSubscriber(newToken, true);
+            });
+        }
+    }
+
+
+    /**
+     * Mark a single notification as send
+     *
+     * @param notificationId
+     */
+    markNotificationAsSeen(notificationId) {
+        const useStaging = store.getState().settingReducer.settingsDevelop.useStaging;
+        const url = useStaging ?  this.notificationStgServerUrl : this.notificationServerUrl
+
+        fetch(
+            `${url}/markAsSeen?subscriberId=${this.subscriberId}&universityCode=${this.universityCode}&notificationId=${notificationId}&useDev=${useStaging}`,
+            {...POSTOptions})
+            .then((response) => response.json())
+            .then(() => {
+                // Notification marked as seen
+            })
+            .catch((error) => {
+                console.warn('Error Code: 1101 : ', error);
+            });
+    }
+
+}

package/libraries/react-native-webview-autoheight/README.md

@@ -0,0 +1,47 @@
+# React Native WebView Autoheight
+React Native WebView which sets it's height automatically with minimal efforts.
+
+You can also add custom CSS style or javascript to your webview using below example.
+
+
+
+![Downloads](https://nodei.co/npm/react-native-webview-autoheight.png?downloads=true&stars=true)
+
+
+
+## Installation
+> npm install --save react-native-webview-autoheight
+
+## Usage
+
+```
+import MyWebView from 'react-native-webview-autoheight';
+const customStyle = "<style>* {max-width: 100%;} body {font-family: sans-serif;} h1 {color: red;}</style>";
+const htmlContent = "<h1>This is title</h1><p>Throw your entire HTML here</p>";
+
+<MyWebView
+    source={{html: customStyle + htmlContent}}
+    startInLoadingState={true}
+/>
+```
+
+```
+<MyWebView
+    source={{uri: 'http://example.com/helloworld.html'}}
+    startInLoadingState={true}
+/>
+```
+
+
+## Props
+* Same as https://facebook.github.io/react-native/docs/webview.html#props
+* `autoHeight` (default: true)
+* `width` (default: Screen width)
+* `defaultHeight` (default height unless autoHeight)
+
+## How it works
+It is a very simple wrapper around the built-in React Native Webview, which updates the height of the webview based on a state change using `onNavigationStateChange`.
+
+
+### Feel free to add issues or feature requests
+