@selfcommunity/react-core 0.1.2-alpha.0

package/lib/cjs/hooks/useSCConnectionsManager.js

@@ -0,0 +1,285 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = useSCConnectionsManager;
+
+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 status method
+ * Check if the user status is 'connected', 'sent_connection_request'
+ * 'received_connection_request', to update the cache and data
+ */
+const STATUS_CONNECTED = 'connected';
+const STATUS_DISCONNECTED = 'disconnected';
+const STATUS_CONNECTION_REQUEST_SENT = 'sent_connection_request';
+const STATUS_CONNECTION_REQUEST_RECEIVED = 'received_connection_request';
+/**
+ :::info
+ This custom hook is used to manage to manage friends.
+ :::
+
+ :::tipHow to use it:
+
+ Follow these steps:
+ ```jsx
+ 1. const scUserContext: SCUserContextType = useSCUser();
+ 2. const scConnectionsManager: SCConnectionsManagerType = scUserContext.manager.connections;
+ 3. scConnectionsManager.status(user)
+ ```
+ :::
+ */
+
+function useSCConnectionsManager(user) {
+  const {
+    cache,
+    updateCache,
+    emptyCache,
+    data,
+    setData,
+    loading,
+    setLoading,
+    isLoading
+  } = (0, _useSCCachingManager.default)();
+  const scPreferencesContext = (0, _SCPreferencesProvider.useSCPreferences)();
+  const connectionsDisabled = _Preferences.CONFIGURATIONS_FOLLOW_ENABLED in scPreferencesContext.preferences && scPreferencesContext.preferences[_Preferences.CONFIGURATIONS_FOLLOW_ENABLED].value;
+  const notificationConnAcceptSubscription = (0, _react.useRef)(null);
+  const notificationConnRequestSubscription = (0, _react.useRef)(null);
+  const notificationConnRemoveSubscription = (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.data.connection.id]);
+      let _data = [];
+
+      if (_Notification.SCNotificationMapping[data.data.activity_type] === _types.SCNotificationTypologyType.CONNECTION_REQUEST) {
+        _data = data.map(([k, v]) => ({
+          k: k === data.data.connection_id ? STATUS_CONNECTION_REQUEST_SENT : v
+        }));
+      } else if (_Notification.SCNotificationMapping[data.data.activity_type] === _types.SCNotificationTypologyType.CONNECTION_ACCEPT) {
+        _data = data.map(([k, v]) => ({
+          k: k === data.data.connection_id ? STATUS_CONNECTED : v
+        }));
+      } else if (_Notification.SCNotificationMapping[data.data.activity_type] === _types.SCNotificationTypologyType.CONNECTION_REMOVE) {
+        _data = data.map(([k, v]) => ({
+          k: k === data.data.connection_id ? STATUS_DISCONNECTED : v
+        }));
+      }
+
+      setData(_data);
+    }
+  };
+  /**
+   * Subscribe to notification types user_follow, user_unfollow
+   */
+
+
+  (0, _react.useEffect)(() => {
+    notificationConnAcceptSubscription.current = _pubsubJs.default.subscribe(`${_types.SCNotificationTopicType.INTERACTION}.${_types.SCNotificationTypologyType.CONNECTION_ACCEPT}`, notificationSubscriber);
+    notificationConnRequestSubscription.current = _pubsubJs.default.subscribe(`${_types.SCNotificationTopicType.INTERACTION}.${_types.SCNotificationTypologyType.CONNECTION_REQUEST}`, notificationSubscriber);
+    notificationConnRemoveSubscription.current = _pubsubJs.default.subscribe(`${_types.SCNotificationTopicType.INTERACTION}.${_types.SCNotificationTypologyType.CONNECTION_REMOVE}`, notificationSubscriber);
+    return () => {
+      _pubsubJs.default.unsubscribe(notificationConnAcceptSubscription.current);
+
+      _pubsubJs.default.unsubscribe(notificationConnRequestSubscription.current);
+
+      _pubsubJs.default.unsubscribe(notificationConnRemoveSubscription.current);
+    };
+  }, []);
+  /**
+   * Memoized refresh all connections
+   * It makes a single request to the server and retrieves
+   * all the users connected 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 !== null).map(([k, v]) => ({
+          [parseInt(k)]: v
+        })));
+        return Promise.resolve(res.data);
+      }).catch(e => {
+        _logger.Logger.error(_Errors.SCOPE_SC_CORE, 'Unable to refresh users Connections by the authenticated user.');
+
+        _logger.Logger.error(_Errors.SCOPE_SC_CORE, e);
+      });
+    }
+  }, [data, user, cache]);
+  /**
+   * Memoized Request connection
+   */
+
+  const requestConnection = (0, _react.useMemo)(() => user => {
+    setLoading(prev => [...prev, ...[user.id]]);
+
+    if (getCurrentStatus(user) === STATUS_CONNECTION_REQUEST_RECEIVED) {
+      return acceptConnection(user);
+    }
+
+    return _apiServices.http.request({
+      url: _apiServices.Endpoints.UserRequestConnection.url({
+        id: user.id
+      }),
+      method: _apiServices.Endpoints.UserRequestConnection.method
+    }).then(res => {
+      if (res.status >= 300) {
+        return Promise.reject(res);
+      }
+
+      updateCache([user.id]);
+
+      const _data = data.map(([k, v]) => ({
+        k: k === user.id ? STATUS_CONNECTION_REQUEST_SENT : v
+      }));
+
+      setData(_data);
+      setLoading(prev => prev.filter(u => u !== user.id));
+      return Promise.resolve(res.data);
+    });
+  }, [data, loading, cache]);
+  /**
+   * Memoized Accept Request connection
+   */
+
+  const acceptConnection = (0, _react.useMemo)(() => user => {
+    setLoading(prev => [...prev, ...[user.id]]);
+
+    if (getCurrentStatus(user) === STATUS_CONNECTION_REQUEST_RECEIVED) {
+      return _apiServices.http.request({
+        url: _apiServices.Endpoints.UserAcceptRequestConnection.url({
+          id: user.id
+        }),
+        method: _apiServices.Endpoints.UserAcceptRequestConnection.method
+      }).then(res => {
+        if (res.status >= 300) {
+          return Promise.reject(res);
+        }
+
+        updateCache([user.id]);
+
+        const _data = data.map(([k, v]) => ({
+          k: k === user.id ? STATUS_CONNECTED : v
+        }));
+
+        setData(_data);
+        setLoading(prev => prev.filter(u => u !== user.id));
+        return Promise.resolve(res.data);
+      });
+    }
+  }, [data, loading, cache]);
+  /**
+   * Return current user status if exist,
+   * otherwise return null
+   */
+
+  const getCurrentStatus = (0, _react.useMemo)(() => user => {
+    const d = data.filter(([id, v]) => id === user.id);
+    return d.length ? d[0][user.id] : null;
+  }, [data]);
+  /**
+   * Check if the authenticated user is connected with the user
+   * Update the users cached
+   * Update user statuses
+   * @param user
+   */
+
+  const checkUserConnectionStatus = user => {
+    setLoading(prev => prev.includes(user.id) ? prev : [...prev, ...[user.id]]);
+
+    _apiServices.http.request({
+      url: _apiServices.Endpoints.UserCheckConnection.url({
+        id: user.id
+      }),
+      method: _apiServices.Endpoints.UserCheckConnection.method
+    }).then(res => {
+      if (res.status >= 300) {
+        return Promise.reject(res);
+      }
+
+      updateCache([user.id]);
+      setData(prev => res.data.is_connection ? [...prev, ...[{
+        [user.id]: STATUS_CONNECTED
+      }]] : prev.filter(([id, v]) => id !== user.id));
+      setLoading(prev => prev.filter(u => u !== user.id));
+      return Promise.resolve(res.data);
+    });
+  };
+  /**
+   * Memoized status
+   * If user is already in cache -> check data user statuses,
+   * otherwise, check if auth user is connected with user
+   */
+
+
+  const status = (0, _react.useMemo)(() => user => {
+    if (cache.includes(user.id)) {
+      return data.filter((k, v) => k === user.id)[0][user.id];
+    }
+
+    if (!loading.includes(user.id)) {
+      checkUserConnectionStatus(user);
+    }
+
+    return null;
+  }, [data, loading, cache]);
+
+  if (connectionsDisabled || !user) {
+    return {
+      connections: data,
+      loading,
+      isLoading
+    };
+  }
+
+  return {
+    connections: data,
+    loading,
+    isLoading,
+    status,
+    requestConnection,
+    acceptConnection,
+    refresh,
+    emptyCache
+  };
+}

package/lib/cjs/hooks/useSCFetchCategories.js

@@ -0,0 +1,71 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = void 0;
+
+var _react = require("react");
+
+var _Errors = require("../constants/Errors");
+
+var _apiServices = require("@selfcommunity/api-services");
+
+var _logger = require("../utils/logger");
+
+var _reactSingletonHook = require("react-singleton-hook");
+
+const init = {
+  categories: [],
+  isLoading: true
+};
+/**
+ :::info
+ This custom hook is used to fetch categories.
+
+ :::tipContext can be consumed in this way:
+
+ ```jsx
+ const {categories, isLoading} = useSCFetchCategories();
+ ```
+ :::
+ */
+
+const useSCFetchCategories = (0, _reactSingletonHook.singletonHook)(init, () => {
+  const [data, setData] = (0, _react.useState)(init);
+  /**
+   * Fetch categories
+   */
+
+  const fetchCategories = async (next = _apiServices.Endpoints.CategoryList.url()) => {
+    const response = await _apiServices.http.request({
+      url: next,
+      method: _apiServices.Endpoints.CategoryList.method
+    });
+    const data = response.data;
+
+    if (data.next) {
+      return data.results.concat(await fetchCategories(data.next));
+    }
+
+    return data.results;
+  };
+  /**
+   * Get categories
+   */
+
+
+  (0, _react.useEffect)(() => {
+    fetchCategories().then(data => {
+      setData({
+        categories: data,
+        isLoading: false
+      });
+    }).catch(error => {
+      console.log(error);
+
+      _logger.Logger.error(_Errors.SCOPE_SC_CORE, 'Unable to retrieve categories');
+    });
+  }, []);
+  return data;
+});
+var _default = useSCFetchCategories;
+exports.default = _default;

package/lib/cjs/hooks/useSCFetchCategory.js

@@ -0,0 +1,68 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = useSCFetchCategory;
+
+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 category object.
+ :::
+ * @param object
+ * @param object.id
+ * @param object.category
+ */
+function useSCFetchCategory({
+  id = null,
+  category = null
+}) {
+  const [scCategory, setSCCategory] = (0, _react.useState)(category);
+  const [error, setError] = (0, _react.useState)(null);
+  /**
+   * Memoized fetchTag
+   */
+
+  const fetchCategory = (0, _react.useMemo)(() => () => {
+    return _apiServices.http.request({
+      url: _apiServices.Endpoints.Category.url({
+        id: id
+      }),
+      method: _apiServices.Endpoints.Category.method
+    }).then(res => {
+      if (res.status >= 300) {
+        return Promise.reject(res);
+      }
+
+      return Promise.resolve(res.data);
+    });
+  }, [id]);
+  /**
+   * If id attempt to get the category by id
+   */
+
+  (0, _react.useEffect)(() => {
+    if (id) {
+      fetchCategory().then(obj => {
+        setSCCategory(obj);
+      }).catch(err => {
+        setError(`Category with id ${id} not found`);
+
+        _logger.Logger.error(_Errors.SCOPE_SC_CORE, `Category with id ${id} not found`);
+
+        _logger.Logger.error(_Errors.SCOPE_SC_CORE, err.message);
+      });
+    }
+  }, [id]);
+  return {
+    scCategory,
+    setSCCategory,
+    error
+  };
+}

package/lib/cjs/hooks/useSCFetchCommentObject.js

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