@olea-bps/base 1.0.0

package/libraries/core/redux/reducers/api.js

@@ -0,0 +1,190 @@
+import { action, commitAction, rollbackAction } from '../../constants/actions';
+import { onUpdateRefreshing } from '../../redux/actions/state';
+import { CourseStatusEnum } from '../../constants/enums';
+import { toIsoDateString } from '../../helper/date';
+
+const selectFeeds = state => state.apiReducer.feeds;
+
+const selectFeedById = (state, feedId) => state.apiReducer.feeds.find(feed => feed.feedid === feedId);
+
+const initialState = {
+    feeds: [],
+    feedItems: [],
+    topNews: [],
+    weather: null,
+    canteens: [],
+    courses: [],
+    coursesStatus: CourseStatusEnum.notImportedYet,
+    jobs: [],
+    menuEntries: []
+};
+
+const apiReducer = (state = initialState, reducerAction) => {
+    switch(reducerAction.type) {
+        case action.feedV3.getFeeds + commitAction:
+            setTimeout(() => {
+                reducerAction.asyncDispatch(onUpdateRefreshing(false));
+            }, 2000);
+            return {
+                ...state,
+                feeds:  Array.isArray(reducerAction.payload.feeds) ? reducerAction.payload.feeds : []
+            };
+        case action.feedV3.getTopNews + commitAction:
+            setTimeout(() => {
+                reducerAction.asyncDispatch(onUpdateRefreshing(false));
+            }, 2000);
+            return {
+                ...state,
+                topNews: Array.isArray(reducerAction.payload.items) ? reducerAction.payload.items : []
+            };
+
+        case action.corona.getCoronaMenu + commitAction:
+            setTimeout(() => {
+                reducerAction.asyncDispatch(onUpdateRefreshing(false));
+            }, 2000);
+            return {
+                ...state,
+                menuEntries: Array.isArray(reducerAction.payload) ? reducerAction.payload : [],
+            };
+
+        case action.canteen.getAll + commitAction:
+            setTimeout(() => {
+                reducerAction.asyncDispatch(onUpdateRefreshing(false));
+            }, 2000);
+
+            // Transform API payload in cache format
+            let newCanteens = reducerAction?.payload?.canteens
+                // Create list of canteens
+                ?.map(apiCanteen => ({
+                    id: apiCanteen.id,
+                    title: apiCanteen.title,
+                    type: apiCanteen.type,
+                    // Create json-object with key as date string and value as meal list
+                    meals: apiCanteen?.menuItems?.reduce((mealMapObject, meal) => {
+                        let meals = mealMapObject[meal.date] ?? []; // Get already grouped meals of current meal date. Is date unkown, create empty array
+                        meals.push(meal);
+                        mealMapObject[meal.date] = meals;
+                        return mealMapObject;
+                    }, {}) ?? {},
+                }))
+                // Create object with key of canteen id and value of canteen
+                ?.reduce((canteensMapObject, apiCanteen) => {
+                    canteensMapObject[apiCanteen.id] = apiCanteen;
+                    return canteensMapObject;
+                }, {});
+
+            // merge cached/old canteen information into new canteens
+            currentDateTime = new Date();
+            lowerCacheAllowDate = new Date(
+                currentDateTime.getFullYear(),
+                currentDateTime.getMonth()+1,
+                currentDateTime.getDate() - 14, // Create datetime 2 weeks in passt
+                currentDateTime.getHours(),
+                currentDateTime.getMinutes(),
+                currentDateTime.getSeconds(),
+                currentDateTime.getMilliseconds()
+            )
+            lowerCacheAllowDate = toIsoDateString(lowerCacheAllowDate);
+            cachedCanteens = state.canteens;
+            // Is canteen cache in old array format?
+            if (!Array.isArray(cachedCanteens)) {
+                for (const [cachedCanteenId, cachedCanteen] of Object.entries(cachedCanteens)) {
+                    // If cached canteen id is not in new canteens, do not merge. Cause this canteen do not exist anymore.
+                    newCanteen = newCanteens?.[cachedCanteenId];
+                    if (newCanteen) {
+                        for (const [cachedCanteenMealsDate, cachedCanteenMeals] of Object.entries(cachedCanteen.meals).filter(([cachedCanteenMealsDate]) => cachedCanteenMealsDate >= lowerCacheAllowDate)) {
+                            // if date is not in new canteen meals, add the cached one to new canteen
+                            if (!newCanteen.meals.hasOwnProperty(cachedCanteenMealsDate)) {
+                                newCanteen.meals[cachedCanteenMealsDate] = cachedCanteenMeals;
+                            }
+                        }
+                    }
+                }
+            }
+
+            return {
+                ...state,
+                canteens: newCanteens,
+            };
+
+        case action.device.postRegisterDevice + commitAction:
+            return state;
+
+        case 'RESET_COURSES':
+            return {
+                ...state,
+                courses: [],
+                coursesStatus: CourseStatusEnum.notImportedYet
+            };
+        case action.coursesV2.getCourses + commitAction:
+            setTimeout(() => {
+                reducerAction.asyncDispatch(onUpdateRefreshing(false));
+            }, 2000);
+            if(reducerAction.payload) {
+                return {
+                    ...state,
+                    courses: Array.isArray(reducerAction.payload) ? reducerAction.payload : [],
+                    coursesStatus: CourseStatusEnum.importSuccessful
+                };
+            } else {
+                return {
+                    ...state,
+                    courses: [],
+                    coursesStatus: CourseStatusEnum.importSuccessful
+                };
+            }
+
+        case action.job.getJobCategories + commitAction:
+          return state;
+
+
+        case action.coursesV2.getCourses + rollbackAction:
+            if(!reducerAction.hideErrors) {
+                if(reducerAction.payload.response && reducerAction.payload.response.message) {
+                    alert(reducerAction.payload.response.message);
+                } else {
+                    alert('Zu diesem Code wurde kein gültiger Stundenplan gefunden!');
+                }
+                return {
+                    ...state,
+                    courses: [],
+                    coursesStatus: CourseStatusEnum.error
+                };
+            }
+            setTimeout(() => {
+                reducerAction.asyncDispatch(onUpdateRefreshing(false));
+            }, 2000);
+            return state;
+
+        case action.feedV3.getFeeds + rollbackAction:
+        case action.feedV3.getTopNews + rollbackAction:
+        case action.corona.getCoronaMenu + rollbackAction:
+            setTimeout(() => {
+                reducerAction.asyncDispatch(onUpdateRefreshing(false));
+            }, 2000);
+            return state;
+
+        case action.canteen.getAll + rollbackAction:
+            setTimeout(() => {
+                reducerAction.asyncDispatch(onUpdateRefreshing(false));
+            }, 2000);
+            return state;
+
+        case action.job.getJobCategories + rollbackAction:
+
+        default:
+            return state;
+    }
+};
+
+const getSortOrderPrices = (title) => {
+    switch (title) {
+        case 'S': return 0;
+        case 'E': return 1;
+        case 'G': return 2;
+    }
+};
+
+export {selectFeeds, selectFeedById, apiReducer as reducer};
+
+export default apiReducer;

package/libraries/core/redux/reducers/index.js

@@ -0,0 +1,32 @@
+/**
+ * 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.
+ */
+
+// @ts-check
+
+import { combineReducers } from 'redux'
+
+import stateReducer from './state'
+import apiReducer from './api'
+import notificationsReducer from './notifications'
+import settingReducer from './setting'
+import { pluginReducer } from '../../../core-plugins';
+
+
+export default combineReducers({
+    apiReducer,
+    notificationsReducer,
+    stateReducer,
+    settingReducer,
+    pluginReducer
+});

package/libraries/core/redux/reducers/notifications.js

@@ -0,0 +1,16 @@
+const initialState = {
+    subscriberId: '',
+};
+
+export default (state = initialState, action) => {
+    switch (action.type) {
+        case 'NOTIFICATIONS_SUBSCRIBER_UPDATE':
+            return {
+                ...state,
+                subscriberId: action.subscriberId
+            };
+    }
+    return state;
+}
+
+

package/libraries/core/redux/reducers/setting.js

@@ -0,0 +1,99 @@
+import { getLocales } from 'expo-localization';
+
+// Derzeitige Hauptsprache des Handys ermitteln
+// Expo garantiert, dass getLocales mindestens ein Element enthält
+const locale = getLocales()[0];
+const lang = locale.languageCode;
+const supportedLanguages = ['de', 'en'];
+
+
+const initialSetting = {
+    favorites: [],
+    favoritesPtsStation: [],
+    settingsGeneral: {language: supportedLanguages.includes(lang) ? lang : 'en'},
+    settingsWeather: {location: 'uni'},
+    settingsCanteens: {favoritePrice: ''},
+    settingsAccessibility: {
+        highContrast: false,
+        increaseFontSize: false
+    },
+    settingsNotifications: {
+        enablePushNotifications: false,
+        enableAllNotifications: false, // Allow all types of notifications, ignores the allowedTypes setting
+        enabledFeedNotifications: [] // Allow only these selected types
+    },
+    settingsDevelop: {
+        useStaging: false,
+        showDeeplinkAlert: false,
+        activeStagingMenuItems: [],
+    },
+    api: {
+        university: 'tuc',
+        rootUrl: 'https://urz-asist.hrz.tu-chemnitz.de/asist-cc/rest'
+        // rootUrl: 'https://asist.hrz.tu-chemnitz.de/asist/rest'
+    }
+};
+import merge from 'lodash/merge';
+
+export default (setting = initialSetting, action) => {
+    if (action.payload) {
+        switch (action.type) {
+            case 'SETTING_UPDATE':
+                return merge({}, setting, action.payload);
+            case 'SETTING_OVERRIDE':
+                return {
+                    ...setting,
+                    favorites: action.payload
+                };
+            case 'SETTING_PTS_STATION_OVERRIDE':
+                return {
+                    ...setting,
+                    favoritesPtsStation: action.payload
+                };
+            case 'SETTING_GENERAL_OVERRIDE':
+                return {
+                    ...setting,
+                    settingsGeneral: action.payload
+                };
+            case 'SETTING_CANTEENS_OVERRIDE':
+                return {
+                    ...setting,
+                    settingsCanteens: action.payload
+                };
+            case 'SETTING_CANTEENS_MERGE':
+                const currentSettingsCanteens = setting?.settingsCanteens ?? {};
+                return {
+                    ...setting,
+                    settingsCanteens: {
+                        ...currentSettingsCanteens,
+                        ...action.payload
+                    }
+                };
+            case 'SETTING_ACCESSIBILITY_OVERRIDE':
+                return {
+                    ...setting,
+                    settingsAccessibility: action.payload
+                };
+            case 'SETTING_NOTIFICATIONS_OVERRIDE':
+                return {
+                    ...setting,
+                    settingsNotifications: action.payload
+                };
+            case 'SETTING_DEVELOP_OVERRIDE':
+                return {
+                    ...setting,
+                    settingsDevelop: action.payload
+                };
+            case 'SETTING_API':
+                return {
+                    ...setting,
+                    api: action.payload
+                };
+            case 'SETTING_CLEAR':
+                return initialSetting;
+        }
+    }
+    return setting;
+}
+
+

package/libraries/core/redux/reducers/state.js

@@ -0,0 +1,122 @@
+const initialState = {
+    view: 'home',
+    refreshing: false,
+    searchTopic: '',
+    searchResults: {
+        books: [],
+        contacts: [],
+        rooms: [],
+        news: []
+    },
+    modalContent: '',
+    newPushMessageShown: false
+};
+
+export default (state = initialState, action) => {
+    switch(action.type) {
+        case 'VIEW_UPDATE':
+            return {
+                ...state,
+                view: action.view
+            };
+
+        case 'UPDATE_REFRESHING_FLAG':
+            return {
+                ...state,
+                refreshing: action.refreshing
+            };
+
+            /**
+             * @deprecated
+             *
+
+        case 'UPDATE_FEED_ITEMS':
+            const feedItems = state.feedItems.map(feedItem => {
+                if(feedItem.id === action.feedItems.id) {
+                    return { ...feedItem, ...action.feedItems.items}
+                }
+                return feedItem;
+            });
+
+            if(feedItems.length === 0 || !feedItems.find(item => item.id === action.feedItems.id)) {
+                feedItems.push(action.feedItems);
+            }
+
+            return {
+                ...state,
+                feedItems: feedItems
+            };
+*/
+        case 'UPDATE_SEARCH_TOPIC':
+            return {
+                ...state,
+                searchTopic: action.searchTopic
+            };
+
+        case 'UPDATE_SEARCH_RESULTS_BOOKS':
+            return {
+                ...state,
+                searchResults: {
+                    ...state.searchResults,
+                    books: action.books
+                }
+            };
+
+        case 'UPDATE_SEARCH_RESULTS_CONTACTS':
+            return {
+                ...state,
+                searchResults: {
+                    ...state.searchResults,
+                    contacts: action.contacts
+                }
+            };
+
+        case 'UPDATE_SEARCH_RESULTS_ROOMS':
+            return {
+                ...state,
+                searchResults: {
+                    ...state.searchResults,
+                    rooms: action.rooms
+                }
+            };
+
+        case 'UPDATE_SEARCH_RESULTS_NEWS':
+            return {
+                ...state,
+                searchResults: {
+                    ...state.searchResults,
+                    news: action.news
+                }
+            };
+
+        case 'UPDATE_MODAL_CONTENT':
+            return {
+                ...state,
+                modalContent: action.modalContent
+            };
+        case 'UPDATE_PUSH_MESSAGE_SHOWN':
+            return {
+                ...state,
+                newPushMessageShown: action.newPushMessageShown
+            };
+
+        default:
+            return state;
+    }
+};
+
+
+const updateObjectInArray = (array, action) => {
+    return array.map((item, index) => {
+        if (index !== action.index) {
+            // This isn't the item we care about - keep it as-is
+            return item
+        }
+
+        // Otherwise, this is the one we want - return an updated value
+        return {
+            ...item,
+            ...action.item
+        }
+    })
+}

package/libraries/core/redux/selectors.js

@@ -0,0 +1,123 @@
+import { useSelector } from 'react-redux';
+
+/**
+ * Selector für Wert, der anzeigt ob die Staging-Server genutzt werden sollen.
+ * @param {Object} reduxState
+ * @returns {boolean} true, wenn die Staging-Server verwendet werden sollen, ansonsten false
+ */
+function selectUseStagingServer(reduxState) {
+    return reduxState?.settingReducer?.settingsDevelop?.useStaging ?? false;
+}
+
+/**
+ * Hook, welcher anzeigt ob die Staging-Server genutzt werden sollen.
+ *
+ * @returns {boolean} true, wenn die Staging-Server verwendet werden sollen, ansonsten false
+ * @example
+ * const isStagingServerActive = useStagingServer();
+ *
+ * console.log('isStagingServerActive' ? 'Staging server active' : 'Productiv server active');
+ */
+export function useStagingServer() {
+    return useSelector(selectUseStagingServer);
+}
+
+/**
+ * Redux-Selector für die in den Einstellungen eingestellte Sprache.
+ * @param {Object} reduxState Der State im Redux
+ * @returns {string|undefined} Spracheinstellung
+ */
+export function selectLanguage(reduxState) {
+    return reduxState?.settingReducer?.settingsGeneral?.language;
+}
+
+/**
+ * Hook, welcher die vom Nutzer eingestellte Sprache zurückliefert.
+ * Die Sprache wird als Zweizeichencode, also `de` für Deutsch und `en` für Englisch, zurückgeliefert.
+ * Konnte die Spracheinstellung nicht abgerufen werden oder ist diese nicht gesetzt, wird `undefined` zurückgeben.
+ *
+ * @returns {string|undefined} Die Sprache als Zweizeichencode. `undefined`, falls keine Sprache eingestellt ist.
+ * @example
+ * const language = useLanguage();
+ *
+ * console.log('Selected language', language);
+ */
+export function useLanguage() {
+    return useSelector(selectLanguage);
+}
+
+export function selectIncreaseFontSize(reduxState) {
+    return reduxState?.settingReducer?.settingsAccessibility?.increaseFontSize ?? false;
+}
+
+
+export function useIncreaseFontSize() {
+    return useSelector(selectIncreaseFontSize);
+}
+
+/**
+ * Redux-Selector für die Subscriber ID
+ * @param {Object} reduxState Der State im Redux
+ * @returns {string|undefined}
+ */
+export function selectSubscriberId(reduxState) {
+    return reduxState?.notificationsReducer?.subscriberId;
+}
+
+/**
+ * Hook, welcher die Subscriber ID vom zurückliefert.
+ * Konnte die Subscriber ID nicht abgerufen werden oder ist diese nicht gesetzt, wird `undefined` zurückgeben.
+ *
+ * @returns {string|undefined} Die Subscriber ID oder `undefined`, falls nicht vorhanden.
+ * @example
+ * const subscriberId = useSubscriberId();
+ *
+ * console.log('Subscriber ID:', subscriberId);
+ */
+export function useSubscriberId() {
+    return useSelector(selectSubscriberId);
+}
+
+/**
+ * Redux-Selector für die Einstellung ob Deeplink-Alarme angezeigt werden sollen.
+ * @param {Object} reduxState Der State im Redux
+ * @returns {boolean}
+ */
+export function selectshowDeeplinkAlert(reduxState) {
+    return reduxState?.settingReducer?.settingsDevelop?.showDeeplinkAlert ?? false;
+}
+
+/**
+ * Hook, welcher die Einstellung, ob Deeplink-Alarme angezeigt werden sollen, zurückliefert.
+ *
+ * @returns {boolean} Sollen Deeplink-Alarme angezeigt werden?
+ * @example
+ * const showDeeplinkAlert = useShowDeeplinkAlert();
+ *
+ * console.log('Show deeplink alarms:', showDeeplinkAlert);
+ */
+export function useShowDeeplinkAlert() {
+    return useSelector(selectshowDeeplinkAlert);
+}
+
+/**
+ * Redux-Selector für die IDs der aktiv geschalteten Menüeinträge, die sonst deaktivert sind.
+ * @param {Object} reduxState Der State im Redux
+ * @returns {string[]}
+ */
+export function selectActiveStagingMenuItems(reduxState) {
+    return reduxState?.settingReducer?.settingsDevelop?.activeStagingMenuItems ?? [];
+}
+
+/**
+ * Hook, welcher die IDs der aktiv geschalteten Menüeinträge, die sonst deaktivert sind, zurückliefert.
+ *
+ * @returns {string[]} Sollen Deeplink-Alarme angezeigt werden?
+ * @example
+ * const activeStagingMenuItems = useActiveStagingMenuItems();
+ *
+ * console.log('Keys of active menu entries:', activeStagingMenuItems);
+ */
+export function useActiveStagingMenuItems() {
+    return useSelector(selectActiveStagingMenuItems);
+}

package/libraries/core/redux/store.js

@@ -0,0 +1,40 @@
+import { createStore, applyMiddleware, compose } from 'redux';
+import { offline } from '../../redux-offline';
+import offlineConfig from '../..//redux-offline/lib/defaults';
+import { persistStore, persistReducer } from 'redux-persist';
+import AsyncStorage from '@react-native-async-storage/async-storage';
+
+import asyncDispatchMiddleware from './asyncDispatch';
+import rootReducer from './reducers';
+
+// Create persist config for redux-persist v6
+// This will handle persisting the entire root state
+const persistConfig = {
+  key: 'root',
+  storage: AsyncStorage,
+  version: 1,
+  // Persist all state except api which might contain temporary data
+  blacklist: ['apiReducer']
+};
+
+// Wrap the root reducer with persistReducer to enable persistence
+const persistedReducer = persistReducer(persistConfig, rootReducer);
+
+// Custom persist function that works with redux-persist v6
+// This replaces redux-offline's internal persistence
+const customPersist = (store, options, callback) => {
+  // Since we're using persistReducer, we just need to call persistStore
+  // without any additional configuration
+  const persistor = persistStore(store, callback);
+  return persistor;
+};
+
+// Create custom offline config that uses our custom persist function
+const customOfflineConfig = {
+  ...offlineConfig,
+  persist: customPersist,
+  persistOptions: {} // Empty since we handle persistence through persistReducer
+};
+
+export const store = createStore(persistedReducer, compose(offline(customOfflineConfig), applyMiddleware(asyncDispatchMiddleware)));
+export const persistor = persistStore(store);