@selfcommunity/react-core 0.1.2-alpha.0

package/lib/esm/hooks/useSCFetchIncubator.js

@@ -0,0 +1,68 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = useSCFetchIncubator;
+
+var _react = require("react");
+
+var _Errors = require("../constants/Errors");
+
+var _apiServices = require("@selfcommunity/api-services");
+
+var _logger = require("../utils/logger");
+
+/**
+ :::info
+ This custom hook is used to fetch an incubator object.
+ :::
+ * @param object
+ * @param object.id
+ * @param object.incubator
+ */
+function useSCFetchIncubator({
+  id = null,
+  incubator = null
+}) {
+  const [scIncubator, setSCIncubator] = (0, _react.useState)(incubator);
+  const [error, setError] = (0, _react.useState)(null);
+  /**
+   * Memoized fetchIncubator
+   */
+
+  const fetchIncubator = (0, _react.useMemo)(() => () => {
+    return _apiServices.http.request({
+      url: _apiServices.Endpoints.GetASpecificIncubator.url({
+        id: id
+      }),
+      method: _apiServices.Endpoints.GetASpecificIncubator.method
+    }).then(res => {
+      if (res.status >= 300) {
+        return Promise.reject(res);
+      }
+
+      return Promise.resolve(res.data);
+    });
+  }, [id]);
+  /**
+   * If id resolve the obj
+   */
+
+  (0, _react.useEffect)(() => {
+    if (id) {
+      fetchIncubator().then(obj => {
+        setSCIncubator(obj);
+      }).catch(err => {
+        setError(`Incubator with id ${id} not found`);
+
+        _logger.Logger.error(_Errors.SCOPE_SC_CORE, `Incubator with id ${id} not found`);
+
+        _logger.Logger.error(_Errors.SCOPE_SC_CORE, err.message);
+      });
+    }
+  }, [id]);
+  return {
+    scIncubator,
+    setSCIncubator,
+    error
+  };
+}

package/lib/esm/hooks/useSCFetchTag.js

@@ -0,0 +1,68 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = useSCFetchTag;
+
+var _react = require("react");
+
+var _Errors = require("../constants/Errors");
+
+var _apiServices = require("@selfcommunity/api-services");
+
+var _logger = require("../utils/logger");
+
+/**
+ :::info
+ This custom hook is used to fetch a tag object.
+ :::
+*  @param object
+ * @param object.id
+ * @param object.tag
+ */
+function useSCFetchTag({
+  id = null,
+  tag = null
+}) {
+  const [scTag, setSCTag] = (0, _react.useState)(tag);
+  const [error, setError] = (0, _react.useState)(null);
+  /**
+   * Memoized fetchTag
+   */
+
+  const fetchTag = (0, _react.useMemo)(() => () => {
+    return _apiServices.http.request({
+      url: _apiServices.Endpoints.Tag.url({
+        id: id
+      }),
+      method: _apiServices.Endpoints.Tag.method
+    }).then(res => {
+      if (res.status >= 300) {
+        return Promise.reject(res);
+      }
+
+      return Promise.resolve(res.data);
+    });
+  }, [id]);
+  /**
+   * If id attempt to get the tag by id
+   */
+
+  (0, _react.useEffect)(() => {
+    if (id) {
+      fetchTag().then(obj => {
+        setSCTag(obj);
+      }).catch(err => {
+        setError(`Tag with id ${id} not found`);
+
+        _logger.Logger.error(_Errors.SCOPE_SC_CORE, `Tag with id ${id} not found`);
+
+        _logger.Logger.error(_Errors.SCOPE_SC_CORE, err.message);
+      });
+    }
+  }, [id]);
+  return {
+    scTag,
+    setSCTag,
+    error
+  };
+}

package/lib/esm/hooks/useSCFetchUser.js

@@ -0,0 +1,68 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = useSCFetchUser;
+
+var _react = require("react");
+
+var _Errors = require("../constants/Errors");
+
+var _apiServices = require("@selfcommunity/api-services");
+
+var _logger = require("../utils/logger");
+
+/**
+ :::info
+ This custom hook is used to fetch a user object.
+ :::
+ * @param object
+ * @param object.id
+ * @param object.user
+ */
+function useSCFetchUser({
+  id = null,
+  user = null
+}) {
+  const [scUser, setSCUser] = (0, _react.useState)(user);
+  const [error, setError] = (0, _react.useState)(null);
+  /**
+   * Memoized fetchUser
+   */
+
+  const fetchUser = (0, _react.useMemo)(() => () => {
+    return _apiServices.http.request({
+      url: _apiServices.Endpoints.User.url({
+        id: id
+      }),
+      method: _apiServices.Endpoints.User.method
+    }).then(res => {
+      if (res.status >= 300) {
+        return Promise.reject(res);
+      }
+
+      return Promise.resolve(res.data);
+    });
+  }, [id]);
+  /**
+   * If id resolve the obj
+   */
+
+  (0, _react.useEffect)(() => {
+    if (id) {
+      fetchUser().then(obj => {
+        setSCUser(obj);
+      }).catch(err => {
+        setError(`User with id ${id} not found`);
+
+        _logger.Logger.error(_Errors.SCOPE_SC_CORE, `User with id ${id} not found`);
+
+        _logger.Logger.error(_Errors.SCOPE_SC_CORE, err.message);
+      });
+    }
+  }, [id]);
+  return {
+    scUser,
+    setSCUser,
+    error
+  };
+}

package/lib/esm/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/esm/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/esm/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
+  };
+}