@selfcommunity/react-core 0.1.2-alpha.0

package/lib/cjs/hooks/useSCFollowedCategoriesManager.js

@@ -0,0 +1,162 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = useSCFollowedCategoriesManager;
+
+var _react = require("react");
+
+var _apiServices = require("@selfcommunity/api-services");
+
+var _useSCCachingManager = _interopRequireDefault(require("./useSCCachingManager"));
+
+var _Errors = require("../constants/Errors");
+
+var _logger = require("../utils/logger");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+/**
+ :::info
+ This custom hook is used to manage the categories followed.
+ :::
+
+ :::tipHow to use it:
+ Follow these steps:
+ ```jsx
+ 1. const scUserContext: SCUserContextType = useSCUser();
+ 2. const scFollowedCategoriesManager: SCFollowedCategoriesManagerType = scUserContext.manager.categories;
+ 3. scFollowedCategoriesManager.isFollowed(category)
+ ```
+ :::
+ */
+function useSCFollowedCategoriesManager(user) {
+  const {
+    cache,
+    updateCache,
+    emptyCache,
+    data,
+    setData,
+    loading,
+    setLoading,
+    isLoading
+  } = (0, _useSCCachingManager.default)();
+  /**
+   * Memoized refresh all categories
+   * It makes a single request to the server and retrieves
+   * all the categories followed by the user in a single solution
+   * It might be useful for multi-tab sync
+   */
+
+  const refresh = (0, _react.useMemo)(() => () => {
+    emptyCache();
+
+    if (user) {
+      // Only if user is authenticated
+      _apiServices.http.request({
+        url: _apiServices.Endpoints.FollowedCategories.url({
+          id: user.id
+        }),
+        method: _apiServices.Endpoints.FollowedCategories.method
+      }).then(res => {
+        if (res.status >= 300) {
+          return Promise.reject(res);
+        }
+
+        const categoryIds = res.data.map(c => c.id);
+        updateCache(categoryIds);
+        setData(categoryIds);
+        return Promise.resolve(res.data);
+      }).catch(e => {
+        _logger.Logger.error(_Errors.SCOPE_SC_CORE, 'Unable to refresh categories followed by the authenticated user.');
+
+        _logger.Logger.error(_Errors.SCOPE_SC_CORE, e);
+      });
+    }
+  }, [data, user, cache]);
+  /**
+   * Memoized follow/unfollow Category
+   * Toggle action
+   */
+
+  const follow = (0, _react.useMemo)(() => category => {
+    setLoading(prev => [...prev, ...[category.id]]);
+    return _apiServices.http.request({
+      url: _apiServices.Endpoints.FollowCategory.url({
+        id: category.id
+      }),
+      method: _apiServices.Endpoints.FollowCategory.method
+    }).then(res => {
+      if (res.status >= 300) {
+        return Promise.reject(res);
+      }
+
+      updateCache([category.id]);
+      const isFollowed = data.includes(category.id);
+      setData(prev => isFollowed ? prev.filter(id => id !== category.id) : [...[category.id], ...prev]);
+      setLoading(prev => prev.filter(c => c !== category.id));
+      return Promise.resolve(res.data);
+    });
+  }, [data, loading, cache]);
+  /**
+   * Check if the user follow the category
+   * Update the categories cached
+   * Update categories followed
+   * @param category
+   */
+
+  const checkIsCategoryFollowed = category => {
+    setLoading(prev => prev.includes(category.id) ? prev : [...prev, ...[category.id]]);
+
+    _apiServices.http.request({
+      url: _apiServices.Endpoints.CheckCategoryIsFollowed.url({
+        id: category.id
+      }),
+      method: _apiServices.Endpoints.CheckCategoryIsFollowed.method
+    }).then(res => {
+      if (res.status >= 300) {
+        return Promise.reject(res);
+      }
+
+      updateCache([category.id]);
+      setData(prev => res.data.is_followed ? [...[category.id], ...prev] : prev.filter(id => id !== category.id));
+      setLoading(prev => prev.filter(c => c !== category.id));
+      return Promise.resolve(res.data);
+    });
+  };
+  /**
+   * Memoized isFollowed
+   * If category is already in cache -> check if the category is in categories,
+   * otherwise, check if user follow the category
+   */
+
+
+  const isFollowed = (0, _react.useMemo)(() => category => {
+    if (cache.includes(category.id)) {
+      return Boolean(data.includes(category.id));
+    }
+
+    if (!loading.includes(category.id)) {
+      checkIsCategoryFollowed(category);
+    }
+
+    return false;
+  }, [data, loading, cache]);
+
+  if (!user) {
+    return {
+      categories: data,
+      loading,
+      isLoading
+    };
+  }
+
+  return {
+    categories: data,
+    loading,
+    isLoading,
+    follow,
+    isFollowed,
+    refresh,
+    emptyCache
+  };
+}

package/lib/cjs/hooks/useSCFollowersManager.js

@@ -0,0 +1,232 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = useSCFollowedManager;
+
+var _react = require("react");
+
+var _apiServices = require("@selfcommunity/api-services");
+
+var _types = require("@selfcommunity/types");
+
+var _logger = require("../utils/logger");
+
+var _Errors = require("../constants/Errors");
+
+var _SCPreferencesProvider = require("../components/provider/SCPreferencesProvider");
+
+var _Preferences = require("../constants/Preferences");
+
+var _useSCCachingManager = _interopRequireDefault(require("./useSCCachingManager"));
+
+var _pubsubJs = _interopRequireDefault(require("pubsub-js"));
+
+var _Notification = require("../constants/Notification");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+/**
+ * Used on refresh and in isFollowed method
+ * Check if the user status is 'followed'
+ * to update the cache and data
+ */
+const STATUS_FOLLOWED = 'followed';
+/**
+ :::info
+ This custom hook is used to manage to manage followed users.
+ :::
+ :::tipHow to use it:
+
+ Follow these steps:
+ ```jsx
+ 1. const scUserContext: SCUserContextType = useSCUser();
+ 2. const scFollowedManager: SCFollowedManagerType = scUserContext.manager.followed;
+ 3. scFollowedManager.isFollowed(user)
+ ```
+ :::
+ */
+
+function useSCFollowedManager(user) {
+  const {
+    cache,
+    updateCache,
+    emptyCache,
+    data,
+    setData,
+    loading,
+    setLoading,
+    isLoading
+  } = (0, _useSCCachingManager.default)();
+  const scPreferencesContext = (0, _SCPreferencesProvider.useSCPreferences)();
+  const followEnabled = _Preferences.CONFIGURATIONS_FOLLOW_ENABLED in scPreferencesContext.preferences && scPreferencesContext.preferences[_Preferences.CONFIGURATIONS_FOLLOW_ENABLED].value;
+  const notificationFollowSubscription = (0, _react.useRef)(null);
+  const notificationUnFollowSubscription = (0, _react.useRef)(null);
+  /**
+   * Notification subscriber only for FOLLOW
+   * @param msg
+   * @param data
+   */
+
+  const notificationSubscriber = (msg, data) => {
+    if (data.connection && data.connection_id !== undefined) {
+      updateCache([data.connection_id]);
+
+      if (_Notification.SCNotificationMapping[data.data.activity_type] === _types.SCNotificationTypologyType.USER_FOLLOW) {
+        if (!data.includes(user.id)) {
+          setData(prev => [...[data.connection_id], ...prev]);
+        }
+      } else if (_Notification.SCNotificationMapping[data.data.activity_type] === _types.SCNotificationTypologyType.USER_UNFOLLOW) {
+        if (data.includes(user.id)) {
+          setData(prev => prev.filter(id => id !== data.connection_id));
+        }
+      }
+    }
+  };
+  /**
+   * Subscribe to notification types user_follow, user_unfollow
+   */
+
+
+  (0, _react.useEffect)(() => {
+    notificationFollowSubscription.current = _pubsubJs.default.subscribe(`${_types.SCNotificationTopicType.INTERACTION}.${_types.SCNotificationTypologyType.USER_FOLLOW}`, notificationSubscriber);
+    notificationUnFollowSubscription.current = _pubsubJs.default.subscribe(`${_types.SCNotificationTopicType.INTERACTION}.${_types.SCNotificationTypologyType.USER_UNFOLLOW}`, notificationSubscriber);
+    return () => {
+      _pubsubJs.default.unsubscribe(notificationFollowSubscription.current);
+
+      _pubsubJs.default.unsubscribe(notificationUnFollowSubscription.current);
+    };
+  }, []);
+  /**
+   * Memoized refresh all followed
+   * It makes a single request to the server and retrieves
+   * all the users followed by the authenticated user in a single solution
+   * It might be useful for multi-tab sync
+   */
+
+  const refresh = (0, _react.useMemo)(() => () => {
+    emptyCache();
+
+    if (user && cache.length > 0) {
+      // Only if user is authenticated
+      _apiServices.http.request({
+        url: _apiServices.Endpoints.UserConnectionStatuses.url({}),
+        method: _apiServices.Endpoints.UserConnectionStatuses.method,
+        data: {
+          users: cache
+        }
+      }).then(res => {
+        if (res.status >= 300) {
+          return Promise.reject(res);
+        }
+
+        updateCache(Object.keys(res.data.connection_statuses).map(id => parseInt(id)));
+        setData(Object.entries(res.data.connection_statuses).filter(([k, v]) => v === STATUS_FOLLOWED).map(([k, v]) => parseInt(k)));
+        return Promise.resolve(res.data);
+      }).catch(e => {
+        _logger.Logger.error(_Errors.SCOPE_SC_CORE, 'Unable to refresh users followed by the authenticated user.');
+
+        _logger.Logger.error(_Errors.SCOPE_SC_CORE, e);
+      });
+    }
+  }, [data, user, cache]);
+  /**
+   * Memoized follow/unfollow User
+   * Toggle action
+   */
+
+  const follow = (0, _react.useMemo)(() => user => {
+    setLoading(prev => [...prev, ...[user.id]]);
+    return _apiServices.http.request({
+      url: _apiServices.Endpoints.FollowUser.url({
+        id: user.id
+      }),
+      method: _apiServices.Endpoints.FollowUser.method
+    }).then(res => {
+      if (res.status >= 300) {
+        return Promise.reject(res);
+      }
+
+      updateCache([user.id]);
+      const isFollowed = data.includes(user.id);
+      setData(prev => isFollowed ? prev.filter(id => id !== user.id) : [...[user.id], ...prev]);
+      setLoading(prev => prev.filter(u => u !== user.id));
+      return Promise.resolve(res.data);
+    });
+  }, [data, loading, cache]);
+  /**
+   * Check if the authenticated user follow the user
+   * Update the followed cached
+   * Update followed user
+   * @param user
+   */
+
+  const checkIsUserFollowed = user => {
+    setLoading(prev => prev.includes(user.id) ? prev : [...prev, ...[user.id]]);
+
+    _apiServices.http.request({
+      url: _apiServices.Endpoints.CheckUserFollowed.url({
+        id: user.id
+      }),
+      method: _apiServices.Endpoints.CheckUserFollowed.method
+    }).then(res => {
+      if (res.status >= 300) {
+        return Promise.reject(res);
+      }
+
+      updateCache([user.id]);
+      setData(prev => res.data.is_followed ? [...prev, ...[user.id]] : prev.filter(id => id !== user.id));
+      setLoading(prev => prev.filter(u => u !== user.id));
+      return Promise.resolve(res.data);
+    });
+  };
+  /**
+   * Bypass remote check if the user is followed
+   */
+
+
+  const getConnectionStatus = (0, _react.useMemo)(() => user => {
+    const isFollowed = user.connection_status === STATUS_FOLLOWED;
+    updateCache([user.id]);
+    setData(prev => isFollowed ? [...prev, ...[user.id]] : prev);
+    return isFollowed;
+  }, [data, cache]);
+  /**
+   * Memoized isFollowed
+   * If user is already in cache -> check if the user is in followed,
+   * otherwise, check if auth user follow the user
+   */
+
+  const isFollowed = (0, _react.useMemo)(() => user => {
+    if (cache.includes(user.id)) {
+      return Boolean(data.includes(user.id));
+    }
+
+    if ('connection_status' in user) {
+      return getConnectionStatus(user);
+    }
+
+    if (!loading.includes(user.id)) {
+      checkIsUserFollowed(user);
+    }
+
+    return false;
+  }, [data, loading, cache]);
+
+  if (!followEnabled || !user) {
+    return {
+      followed: data,
+      loading,
+      isLoading
+    };
+  }
+
+  return {
+    followed: data,
+    loading,
+    isLoading,
+    follow,
+    isFollowed,
+    refresh,
+    emptyCache
+  };
+}

package/lib/cjs/hooks/useSCMediaClick.js

@@ -0,0 +1,27 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = useSCMediaClick;
+
+var _apiServices = require("@selfcommunity/api-services");
+
+var _logger = require("../utils/logger");
+
+var _Errors = require("../constants/Errors");
+
+function useSCMediaClick() {
+  const handleMediaClick = mediaObj => {
+    _apiServices.http.request({
+      url: _apiServices.Endpoints.MediaClickTracker.url({
+        id: mediaObj.id
+      }),
+      method: _apiServices.Endpoints.MediaClickTracker.method
+    }).catch(error => {
+      _logger.Logger.error(_Errors.SCOPE_SC_CORE, error);
+    });
+  };
+
+  return {
+    handleMediaClick
+  };
+}

package/lib/cjs/hooks/useSCSubscribedIncubatorsManager.js

@@ -0,0 +1,165 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = useSCSubscribedIncubatorsManager;
+
+var _react = require("react");
+
+var _apiServices = require("@selfcommunity/api-services");
+
+var _logger = require("../utils/logger");
+
+var _Errors = require("../constants/Errors");
+
+var _useSCCachingManager = _interopRequireDefault(require("./useSCCachingManager"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+/**
+ :::info
+ This custom hook is used to manage to manage subscribed incubators.
+ :::
+ :::tipHow to use it:
+
+ Follow these steps:
+ ```jsx
+ 1. const scUserContext: SCUserContextType = useSCUser();
+ 2. const scSubscribedIncubatorsManager: SCSubscribedIncubatorsManagerType = scUserContext.managers.incubators;
+ 3. scSubscribedIncubatorsManager.isSubscribed(incubator)
+ ```
+ :::
+ */
+function useSCSubscribedIncubatorsManager(user) {
+  const {
+    cache,
+    updateCache,
+    emptyCache,
+    data,
+    setData,
+    loading,
+    setLoading,
+    isLoading
+  } = (0, _useSCCachingManager.default)();
+  /**
+   * Memoized refresh all subscribed
+   * It makes a single request to the server and retrieves
+   * all the incubators subscribed by the authenticated user in a single solution
+   * It might be useful for multi-tab sync
+   */
+
+  const refresh = (0, _react.useMemo)(() => () => {
+    emptyCache();
+
+    if (user) {
+      // Only if user is authenticated
+      _apiServices.http.request({
+        url: _apiServices.Endpoints.GetAllIncubators.url({}),
+        method: _apiServices.Endpoints.GetAllIncubators.method
+      }).then(res => {
+        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)));
+        return Promise.resolve(res.data);
+      }).catch(e => {
+        _logger.Logger.error(_Errors.SCOPE_SC_CORE, 'Unable to refresh incubators subscribed by the authenticated user.');
+
+        _logger.Logger.error(_Errors.SCOPE_SC_CORE, e);
+      });
+    }
+  }, [data, user, cache]);
+  /**
+   * Memoized subscribe/unsubscribe incubator
+   * Toggle action
+   */
+
+  const subscribe = (0, _react.useMemo)(() => incubator => {
+    setLoading(prev => [...prev, ...[incubator.id]]);
+    return _apiServices.http.request({
+      url: _apiServices.Endpoints.SubscribeToIncubator.url({
+        id: incubator.id
+      }),
+      method: _apiServices.Endpoints.SubscribeToIncubator.method
+    }).then(res => {
+      if (res.status >= 300) {
+        return Promise.reject(res);
+      }
+
+      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));
+      return Promise.resolve(res.data);
+    });
+  }, [data, loading, cache]);
+  /**
+   * Check if the authenticated user has subscribed the incubator
+   * Update the subscribed cached
+   * Update subscribed incubators
+   * @param incubator
+   */
+
+  const checkIsIncubatorFollowed = incubator => {
+    setLoading(prev => prev.includes(incubator.id) ? prev : [...prev, ...[incubator.id]]);
+
+    _apiServices.http.request({
+      url: _apiServices.Endpoints.CheckIncubatorSubscription.url({
+        id: incubator.id
+      }),
+      method: _apiServices.Endpoints.CheckIncubatorSubscription.method
+    }).then(res => {
+      if (res.status >= 300) {
+        return Promise.reject(res);
+      }
+
+      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));
+      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]
+  // );
+
+  /**
+   * Memoized isSubscribed
+   * If incubator is already in cache -> check if the incubator is in subscribed,
+   * otherwise, check if auth user is subscribed to the incubator
+   */
+
+
+  const isSubscribed = (0, _react.useMemo)(() => incubator => {
+    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);
+    }
+
+    return false;
+  }, [data, loading, cache]);
+  return {
+    incubators: data,
+    loading,
+    isLoading,
+    subscribe,
+    isSubscribed,
+    refresh,
+    emptyCache
+  };
+}