@selfcommunity/react-core 0.4.0-alpha.11 → 0.4.0-alpha.111

package/lib/cjs/hooks/useSCMobileNativePushMessaging.js

@@ -0,0 +1,143 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const react_1 = require("react");
+const SCContextProvider_1 = require("../components/provider/SCContextProvider");
+const SCUserProvider_1 = require("../components/provider/SCUserProvider");
+const utils_1 = require("@selfcommunity/utils");
+const Errors_1 = require("../constants/Errors");
+const api_services_1 = require("@selfcommunity/api-services");
+const Device_1 = require("../constants/Device");
+const notification_1 = require("../utils/notification");
+/**
+ :::info
+ This custom hook is used to manage native push notification:
+ - register device (Android/iOS)
+ - unregister device (Android/iOS)
+ !important: the device is registered only if exist in the global window
+             object (or as keys in the localstorage) the follow:
+             - _platform: <android|iOS>
+             - _notification_service: <gcm:fcm:apns>
+             - _registration_id: <registration_id>
+             - _device_id: <device_id>
+ :::
+ */
+function useSCMobileNativePushMessaging() {
+    const scContext = (0, SCContextProvider_1.useSCContext)();
+    const scUserContext = (0, SCUserProvider_1.useSCUser)();
+    const [mnpmInstance, setMnpmInstance] = (0, react_1.useState)(null);
+    const [isLoading, setLoading] = (0, react_1.useState)(false);
+    /**
+     * Validate notification service
+     * @param data
+     */
+    const isValid = (data) => {
+        return (data &&
+            data.registration_id &&
+            ((data.platform === Device_1.PLATFORM.ANDROID &&
+                (data.notification_service === Device_1.ANDROID_PUSH_NOTIFICATION_GCM_DEVICE_TYPE ||
+                    data.notification_service === Device_1.ANDROID_PUSH_NOTIFICATION_FCM_DEVICE_TYPE)) ||
+                (data.platform === Device_1.PLATFORM.IOS &&
+                    (data.notification_service === Device_1.IOS_PUSH_NOTIFICATION_IOS_DEVICE_TYPE ||
+                        data.notification_service === Device_1.ANDROID_PUSH_NOTIFICATION_FCM_DEVICE_TYPE))));
+    };
+    /**
+     * Perform device registration
+     * @param data
+     * @param remove
+     */
+    const performUpdateDevice = (data, remove = false) => {
+        const url = remove
+            ? api_services_1.Endpoints.DeleteDevice.url({ type: data.notification_service, id: data.registration_id })
+            : api_services_1.Endpoints.NewDevice.url({ type: data.notification_service });
+        const method = remove ? api_services_1.Endpoints.DeleteDevice.method : api_services_1.Endpoints.NewDevice.method;
+        setLoading(true);
+        return api_services_1.http
+            .request(Object.assign({ url,
+            method }, (remove
+            ? {}
+            : {
+                data: Object.assign({ registration_id: data.registration_id, cloud_message_type: data.notification_service.toUpperCase(), name: `${data.platform} device` }, (data.device_id ? { device_id: data.device_id } : {})),
+            })))
+            .then((res) => {
+            if (res.status >= 300) {
+                return Promise.reject(res);
+            }
+            setLoading(false);
+            return Promise.resolve(res.data);
+        })
+            .catch((e) => {
+            setLoading(false);
+            return Promise.reject(e);
+        });
+    };
+    /**
+     * Collect data
+     */
+    const getDataInstance = () => {
+        if (window &&
+            window[Device_1.PLATFORM_KEY] &&
+            Device_1.PLATFORMS.includes(window[Device_1.PLATFORM_KEY]) &&
+            window[Device_1.REGISTRATION_ID_KEY] &&
+            window[Device_1.NOTIFICATION_SERVICE_KEY] &&
+            Device_1.NOTIFICATIONS_SERVICES.includes(window[Device_1.NOTIFICATION_SERVICE_KEY])) {
+            return Object.assign({ platform: window[Device_1.PLATFORM_KEY], registration_id: window[Device_1.REGISTRATION_ID_KEY], notification_service: window[Device_1.NOTIFICATION_SERVICE_KEY] }, (window[Device_1.DEVICE_ID_KEY] ? { device_id: window[Device_1.DEVICE_ID_KEY] } : {}));
+        }
+        else if (utils_1.LocalStorageDB.checkifSupport() &&
+            utils_1.LocalStorageDB.get(Device_1.PLATFORM_KEY) &&
+            Device_1.PLATFORMS.includes(utils_1.LocalStorageDB.get(Device_1.PLATFORM_KEY)) &&
+            utils_1.LocalStorageDB.get(Device_1.REGISTRATION_ID_KEY) &&
+            utils_1.LocalStorageDB.get(Device_1.NOTIFICATION_SERVICE_KEY) &&
+            Device_1.NOTIFICATIONS_SERVICES.includes(utils_1.LocalStorageDB.get(Device_1.NOTIFICATION_SERVICE_KEY))) {
+            return Object.assign({ platform: utils_1.LocalStorageDB.get(Device_1.PLATFORM_KEY), registration_id: utils_1.LocalStorageDB.get(Device_1.REGISTRATION_ID_KEY), notification_service: utils_1.LocalStorageDB.get(Device_1.NOTIFICATION_SERVICE_KEY) }, (window[Device_1.DEVICE_ID_KEY] ? { device_id: window[Device_1.DEVICE_ID_KEY] } : {}));
+        }
+        else {
+            return null;
+        }
+    };
+    /**
+     * Unsubscribe device
+     */
+    const unsubscribeDevice = () => {
+        if (mnpmInstance && !isLoading) {
+            utils_1.Logger.info(Errors_1.SCOPE_SC_CORE, 'Mobile native notification is disabled. Unregister the device.');
+            performUpdateDevice(mnpmInstance, true)
+                .then((res) => {
+                setMnpmInstance(null);
+                utils_1.Logger.info(Errors_1.SCOPE_SC_CORE, 'Device unregistration successful. Your device will not be able to receive mobile push notifications.');
+            })
+                .catch(() => {
+                setMnpmInstance(null);
+            });
+        }
+    };
+    /**
+     * Check if there is a currently active session and a
+     * instance when the provider is mounted for the first time.
+     */
+    (0, react_1.useEffect)(() => {
+        if (scUserContext.user && (0, notification_1.isMobileNativeNotificationEnabled)() && !scContext.settings.notifications.mobileNativePushMessaging.disable) {
+            const _data = getDataInstance();
+            if (isValid(_data)) {
+                if ((!mnpmInstance || (mnpmInstance && mnpmInstance.registration_id !== _data.registration_id)) && !isLoading) {
+                    utils_1.Logger.info(Errors_1.SCOPE_SC_CORE, 'Mobile native notification is enabled. Checking and validate data...');
+                    // Register the device only if app-platform and app-registrationId and app-notificationService
+                    // exists in window/localStorage
+                    utils_1.Logger.info(Errors_1.SCOPE_SC_CORE, 'Data is valid to register the device for receive mobile push notification.');
+                    performUpdateDevice(_data).then((res) => {
+                        setMnpmInstance(Object.assign(Object.assign({}, _data), { id: res.id }));
+                        utils_1.Logger.info(Errors_1.SCOPE_SC_CORE, 'Device registration successful. Your device will now be able to receive mobile push notifications.');
+                    });
+                }
+            }
+            else {
+                utils_1.Logger.warn(Errors_1.SCOPE_SC_CORE, 'Invalid data. Unable to register the device for native push notification.');
+                unsubscribeDevice();
+            }
+        }
+        else {
+            unsubscribeDevice();
+        }
+    });
+    return { mnpmInstance, setMnpmInstance };
+}
+exports.default = useSCMobileNativePushMessaging;

package/lib/cjs/hooks/useSCSettingsManager.d.ts

@@ -20,4 +20,3 @@ export default function useSCSettingsManager(user?: SCUserType): {
     isLoading: () => boolean;
     refresh: () => void;
 };
-//# sourceMappingURL=useSCSettingsManager.d.ts.map

package/lib/cjs/hooks/useSCSettingsManager.js

@@ -98,4 +98,3 @@ function useSCSettingsManager(user) {
     return { update, get, all, isLoading, refresh };
 }
 exports.default = useSCSettingsManager;
-//# sourceMappingURL=useSCSettingsManager.js.map

package/lib/cjs/hooks/useSCSubscribedIncubatorsManager.d.ts

@@ -15,8 +15,18 @@ import { SCIncubatorType, SCUserType } from '@selfcommunity/types';
  */
 export default function useSCSubscribedIncubatorsManager(user?: SCUserType): {
     incubators: any[];
-    loading: number[];
-    isLoading: (obj: {
+    loading: any[];
+    isLoading: (v: number | {
+        id: number;
+    }) => boolean;
+    subscribe?: undefined;
+    isSubscribed?: undefined;
+    refresh?: undefined;
+    emptyCache?: undefined;
+} | {
+    incubators: any[];
+    loading: any[];
+    isLoading: (v: number | {
         id: number;
     }) => boolean;
     subscribe: (incubator: SCIncubatorType) => Promise<any>;
@@ -24,4 +34,3 @@ export default function useSCSubscribedIncubatorsManager(user?: SCUserType): {
     refresh: () => void;
     emptyCache: () => void;
 };
-//# sourceMappingURL=useSCSubscribedIncubatorsManager.d.ts.map

package/lib/cjs/hooks/useSCSubscribedIncubatorsManager.js

@@ -1,13 +1,11 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
 const react_1 = require("react");
 const api_services_1 = require("@selfcommunity/api-services");
 const utils_1 = require("@selfcommunity/utils");
 const Errors_1 = require("../constants/Errors");
-const useSCCachingManager_1 = __importDefault(require("./useSCCachingManager"));
+const useSCCachingManager_1 = tslib_1.__importDefault(require("./useSCCachingManager"));
 /**
  :::info
  This custom hook is used to manage to manage subscribed incubators.
@@ -23,7 +21,8 @@ const useSCCachingManager_1 = __importDefault(require("./useSCCachingManager"));
  :::
  */
 function useSCSubscribedIncubatorsManager(user) {
-    const { cache, updateCache, emptyCache, data, setData, loading, setLoading, isLoading } = (0, useSCCachingManager_1.default)();
+    const { cache, updateCache, emptyCache, data, setData, loading, setLoading, setUnLoading, isLoading } = (0, useSCCachingManager_1.default)();
+    const authUserId = user ? user.id : null;
     /**
      * Memoized refresh all subscribed
      * It makes a single request to the server and retrieves
@@ -43,10 +42,9 @@ function useSCSubscribedIncubatorsManager(user) {
                 if (res.status >= 300) {
                     return Promise.reject(res);
                 }
-                updateCache(Object.keys(res.data.results).map((id) => parseInt(id)));
-                setData(Object.entries(res.data.results)
-                    .filter(([k, v]) => v === true)
-                    .map(([k, v]) => parseInt(k)));
+                const incubatorIds = res.data.results.map((i) => i.id);
+                updateCache(incubatorIds);
+                setData(incubatorIds);
                 return Promise.resolve(res.data);
             })
                 .catch((e) => {
@@ -60,7 +58,7 @@ function useSCSubscribedIncubatorsManager(user) {
      * Toggle action
      */
     const subscribe = (0, react_1.useMemo)(() => (incubator) => {
-        setLoading((prev) => [...prev, ...[incubator.id]]);
+        setLoading(incubator.id);
         return api_services_1.http
             .request({
             url: api_services_1.Endpoints.SubscribeToIncubator.url({ id: incubator.id }),
@@ -73,7 +71,7 @@ function useSCSubscribedIncubatorsManager(user) {
             updateCache([incubator.id]);
             const isSubscribed = data.includes(incubator.id);
             setData((prev) => (isSubscribed ? prev.filter((id) => id !== incubator.id) : [...[incubator.id], ...prev]));
-            setLoading((prev) => prev.filter((i) => i !== incubator.id));
+            setUnLoading(incubator.id);
             return Promise.resolve(res.data);
         });
     }, [data, loading, cache]);
@@ -84,7 +82,7 @@ function useSCSubscribedIncubatorsManager(user) {
      * @param incubator
      */
     const checkIsIncubatorFollowed = (incubator) => {
-        setLoading((prev) => (prev.includes(incubator.id) ? prev : [...prev, ...[incubator.id]]));
+        setLoading(incubator.id);
         api_services_1.http
             .request({
             url: api_services_1.Endpoints.CheckIncubatorSubscription.url({ id: incubator.id }),
@@ -96,22 +94,19 @@ function useSCSubscribedIncubatorsManager(user) {
             }
             updateCache([incubator.id]);
             setData((prev) => (res.data.subscribed ? [...prev, ...[incubator.id]] : prev.filter((id) => id !== incubator.id)));
-            setLoading((prev) => prev.filter((i) => i !== incubator.id));
+            setUnLoading(incubator.id);
             return Promise.resolve(res.data);
         });
     };
-    // /**
-    //  * Bypass remote check if the incubator is subscribed
-    //  */
-    // const getSubscriptionStatus = useMemo(
-    //   () => (incubator: SCIncubatorType) => {
-    //     const isSubscribed = incubator.subscribed === true;
-    //     updateCache([incubator.id]);
-    //     setData((prev) => (isSubscribed ? [...prev, ...[incubator.id]] : prev));
-    //     return isSubscribed;
-    //   },
-    //   [data, cache]
-    // );
+    /**
+     * Bypass remote check if the incubator is subscribed
+     */
+    const getSubscriptionStatus = (0, react_1.useMemo)(() => (incubator) => {
+        const isSubscribed = incubator.subscribed || false;
+        updateCache([incubator.id]);
+        setData((prev) => (isSubscribed ? [...prev, ...[incubator.id]] : prev));
+        return isSubscribed;
+    }, [data, cache]);
     /**
      * Memoized isSubscribed
      * If incubator is already in cache -> check if the incubator is in subscribed,
@@ -121,15 +116,27 @@ function useSCSubscribedIncubatorsManager(user) {
         if (cache.includes(incubator.id)) {
             return Boolean(data.includes(incubator.id));
         }
-        // if ('subscribed' in incubator) {
-        //   return getSubscriptionStatus(incubator);
-        // }
-        if (!loading.includes(incubator.id)) {
-            checkIsIncubatorFollowed(incubator);
+        if (authUserId) {
+            if ('subscribed' in incubator) {
+                return getSubscriptionStatus(incubator);
+            }
+            if (!isLoading(incubator)) {
+                checkIsIncubatorFollowed(incubator);
+            }
         }
         return false;
-    }, [data, loading, cache]);
+    }, [data, loading, cache, authUserId]);
+    /**
+     * Empty cache on logout
+     */
+    (0, react_1.useEffect)(() => {
+        if (!authUserId) {
+            emptyCache();
+        }
+    }, [authUserId]);
+    if (!user) {
+        return { incubators: data, loading, isLoading };
+    }
     return { incubators: data, loading, isLoading, subscribe, isSubscribed, refresh, emptyCache };
 }
 exports.default = useSCSubscribedIncubatorsManager;
-//# sourceMappingURL=useSCSubscribedIncubatorsManager.js.map

package/lib/cjs/hooks/useSCUserIsBlocked.d.ts

@@ -0,0 +1,18 @@
+import { SCUserType } from '@selfcommunity/types';
+/**
+ :::info
+ This custom hook is used to check if the user is blocked by me or I am blocked by him.
+ :::
+ :::tipHow to use it:
+
+ Follow these steps:
+ ```jsx
+ 1. import useUserIsBlocked from '@selfcommunity/react-core';
+ 2.	const {blocked, loading: loadingBlockedBy} = useUserIsBlocked(user);
+ ```
+ :::
+ */
+export default function useSCUserIsBlocked(user: SCUserType): {
+    blocked: boolean;
+    loading: boolean;
+};

package/lib/cjs/hooks/useSCUserIsBlocked.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+const react_1 = require("react");
+const useSCFetchUserBlockedBy_1 = tslib_1.__importDefault(require("./useSCFetchUserBlockedBy"));
+const SCUserProvider_1 = require("../components/provider/SCUserProvider");
+/**
+ :::info
+ This custom hook is used to check if the user is blocked by me or I am blocked by him.
+ :::
+ :::tipHow to use it:
+
+ Follow these steps:
+ ```jsx
+ 1. import useUserIsBlocked from '@selfcommunity/react-core';
+ 2.	const {blocked, loading: loadingBlockedBy} = useUserIsBlocked(user);
+ ```
+ :::
+ */
+function useSCUserIsBlocked(user) {
+    // CONTEXT
+    const scUserContext = (0, SCUserProvider_1.useSCUser)();
+    // HOOKS
+    const { blockedBy, loading: loadingBlockedBy } = (0, useSCFetchUserBlockedBy_1.default)({ user });
+    // CONST
+    const isMe = (0, react_1.useMemo)(() => scUserContext.user && user.id === scUserContext.user.id, [scUserContext.user, user]);
+    // Status blocked
+    const blocked = !isMe && user && Boolean((scUserContext.user && scUserContext.managers.blockedUsers.isBlocked(user)) || blockedBy);
+    // Status loading
+    const loading = scUserContext.user && (scUserContext.managers.blockedUsers.isLoading() || loadingBlockedBy);
+    return { blocked, loading };
+}
+exports.default = useSCUserIsBlocked;

package/lib/cjs/hooks/useSCWebPushMessaging.d.ts

@@ -1,9 +1,19 @@
+import { SnackbarKey } from 'notistack';
+/**
+ * Browser supported on backend
+ */
+export declare const CHROME_BROWSER_TYPE = "chrome";
+export declare const FIREFOX_BROWSER_TYPE = "firefox";
+export declare const OPERA_BROWSER_TYPE = "opera";
+export declare const EDGE_BROWSER_TYPE = "edge";
+export declare const DEFAULT_BROWSER_TYPE = "chrome";
+export declare const SUPPORTED_BROWSER_TYPES: string[];
 /**
  :::info
- This custom hook is used to to init web push messaging.
+ This custom hook is used to init web push messaging.
  :::
  */
 export default function useSCWebPushMessaging(): {
     wpSubscription: any;
+    requestNotificationPermission: (snackbarId: SnackbarKey | null) => void;
 };
-//# sourceMappingURL=useSCWebPushMessaging.d.ts.map