@selfcommunity/react-core 0.7.0-alpha.2 → 0.7.0-alpha.20

package/lib/esm/constants/Preferences.js

@@ -82,6 +82,8 @@ export const ADDONS_POST_GEOLOCATION_ENABLED = `${SCPreferenceSection.ADDONS}.${
 export const ADDONS_SHARE_POST_ON_FACEBOOK_ENABLED = `${SCPreferenceSection.ADDONS}.${SCPreferenceName.SHARE_POST_ON_FACEBOOK_ENABLED}`;
 export const ADDONS_SHARE_POST_ON_TWITTER_ENABLED = `${SCPreferenceSection.ADDONS}.${SCPreferenceName.SHARE_POST_ON_TWITTER_ENABLED}`;
 export const ADDONS_SHARE_POST_ON_LINKEDIN_ENABLED = `${SCPreferenceSection.ADDONS}.${SCPreferenceName.SHARE_POST_ON_LINKEDIN_ENABLED}`;
+export const ADDONS_PRIVATE_MESSAGES_ENABLED = `${SCPreferenceSection.ADDONS}.${SCPreferenceName.PRIVATE_MESSAGES_ENABLED}`;
+export const ADDONS_SHARE_POST_ENABLED = `${SCPreferenceSection.ADDONS}.${SCPreferenceName.SHARE_POST_ENABLED}`;
 /**
  * ADVERTISING
  */
@@ -90,6 +92,7 @@ export const ADVERTISING_CUSTOM_ADV_ONLY_FOR_ANONYMOUS_USERS_ENABLED = `${SCPref
 /**
  * CONFIGURATIONS
  */
+export const CONFIGURATIONS_CONNECTION_ENABLED = `${SCPreferenceSection.CONFIGURATIONS}.${SCPreferenceName.CONNECTION_ENABLED}`;
 export const CONFIGURATIONS_FOLLOW_ENABLED = `${SCPreferenceSection.CONFIGURATIONS}.${SCPreferenceName.FOLLOW_ENABLED}`;
 export const CONFIGURATIONS_EXPLORE_STREAM_ENABLED = `${SCPreferenceSection.CONFIGURATIONS}.${SCPreferenceName.EXPLORE_STREAM_ENABLED}`;
 export const CONFIGURATIONS_EXPLORE_STREAM_ORDER_BY = `${SCPreferenceSection.CONFIGURATIONS}.${SCPreferenceName.EXPLORE_STREAM_ORDER_BY}`;
@@ -147,6 +150,20 @@ export const CONFIGURATIONS_LIVE_STREAM_ENABLED = `${SCPreferenceSection.CONFIGU
 export const CONFIGURATIONS_LIVE_STREAM_ONLY_STAFF_ENABLED = `${SCPreferenceSection.CONFIGURATIONS}.${SCPreferenceName.LIVE_STREAM_ONLY_STAFF_ENABLED}`;
 export const CONFIGURATIONS_LIVE_VIDEO_CONFERENCE_ENABLED = `${SCPreferenceSection.CONFIGURATIONS}.${SCPreferenceName.LIVE_STREAM_VIDEO_CONFERENCE_ENABLED}`;
 export const CONFIGURATIONS_SUBSCRIPTION_TIER = `${SCPreferenceSection.CONFIGURATIONS}.${SCPreferenceName.SUBSCRIPTION_TIER}`;
+export const CONFIGURATIONS_PAYMENTS_ENABLED = `${SCPreferenceSection.CONFIGURATIONS}.${SCPreferenceName.PAYMENTS_ENABLED}`;
+export const CONFIGURATIONS_STRIPE_CONNECTED_ACCOUNT_ID = `${SCPreferenceSection.CONFIGURATIONS}.${SCPreferenceName.STRIPE_CONNECTED_ACCOUNT_ID}`;
+export const CONFIGURATIONS_CONTEXT_MENU_ENABLED = `${SCPreferenceSection.CONFIGURATIONS}.${SCPreferenceName.CONTEXT_MENU_ENABLED}`;
+export const CONFIGURATIONS_CATEGORY_FOLLOW_ENABLED = `${SCPreferenceSection.CONFIGURATIONS}.${SCPreferenceName.CATEGORY_FOLLOW_ENABLED}`;
+export const CONFIGURATIONS_COMMENTS_ENABLED = `${SCPreferenceSection.CONFIGURATIONS}.${SCPreferenceName.COMMENTS_ENABLED}`;
+export const CONFIGURATIONS_SIDEBAR_SHOW_ALL_CATEGORIES_ENABLED = `${SCPreferenceSection.CONFIGURATIONS}.${SCPreferenceName.SIDEBAR_SHOW_ALL_CATEGORIES_ENABLED}`;
+export const CONFIGURATIONS_VIDEO_AUTOPLAY_ENABLED = `${SCPreferenceSection.CONFIGURATIONS}.${SCPreferenceName.VIDEO_AUTOPLAY_ENABLED}`;
+export const CONFIGURATIONS_VIDEO_PLAY_TRACKING_DELAY_SECONDS = `${SCPreferenceSection.CONFIGURATIONS}.${SCPreferenceName.VIDEO_PLAY_TRACKING_DELAY_SECONDS}`;
+export const CONFIGURATIONS_SCHEDULED_POSTS_ENABLED = `${SCPreferenceSection.CONFIGURATIONS}.${SCPreferenceName.SCHEDULED_POSTS_ENABLED}`;
+export const CONFIGURATIONS_POST_CATEGORY_REQUIRED_ENABLED = `${SCPreferenceSection.CONFIGURATIONS}.${SCPreferenceName.POST_CATEGORY_REQUIRED_ENABLED}`;
+export const CONFIGURATIONS_POST_ADDRESSING_REQUIRED_ENABLED = `${SCPreferenceSection.CONFIGURATIONS}.${SCPreferenceName.POST_ADDRESSING_REQUIRED_ENABLED}`;
+export const CONFIGURATIONS_POST_USER_ADDRESSING_ENABLED = `${SCPreferenceSection.CONFIGURATIONS}.${SCPreferenceName.POST_USER_ADDRESSING_ENABLED}`;
+export const CONFIGURATIONS_CONTACT_API_ENABLED = `${SCPreferenceSection.CONFIGURATIONS}.${SCPreferenceName.CONTACT_API_ENABLED}`;
+export const CONFIGURATIONS_ACCEPTED_MEDIA_MIMETYPES = `${SCPreferenceSection.CONFIGURATIONS}.${SCPreferenceName.ACCEPTED_MEDIA_MIMETYPES}`;
 /**
  * PROVIDERS
  */
@@ -178,6 +195,7 @@ export const WEBMASTER_META_DESCRIPTION = `${SCPreferenceSection.WEBMASTER}.${SC
  */
 export const STATIC_ENVIRONMENT = `${SCPreferenceSection.STATIC}.${SCPreferenceName.ENVIRONMENT}`;
 export const STATIC_STACKID = `${SCPreferenceSection.STATIC}.${SCPreferenceName.STACK_ID}`;
+export const STATIC_STRIPE_PUBLIC_KEY = `${SCPreferenceSection.STATIC}.${SCPreferenceName.STRIPE_PUBLIC_KEY}`;
 const booleanType = (value) => {
     if (value === 'True') {
         return true;
@@ -252,6 +270,7 @@ export const DATA_TYPES = {
     [ADDONS_SHARE_POST_ON_FACEBOOK_ENABLED]: booleanType,
     [ADDONS_SHARE_POST_ON_TWITTER_ENABLED]: booleanType,
     [ADDONS_SHARE_POST_ON_LINKEDIN_ENABLED]: booleanType,
+    [ADDONS_SHARE_POST_ENABLED]: booleanType,
     [CONFIGURATIONS_FOLLOW_ENABLED]: booleanType,
     [CONFIGURATIONS_EXPLORE_STREAM_ENABLED]: booleanType,
     [CONFIGURATIONS_EXPLORE_STREAM_ORDER_BY]: stringType,
@@ -308,6 +327,17 @@ export const DATA_TYPES = {
     [CONFIGURATIONS_LIVE_STREAM_ONLY_STAFF_ENABLED]: booleanType,
     [CONFIGURATIONS_LIVE_VIDEO_CONFERENCE_ENABLED]: booleanType,
     [CONFIGURATIONS_SUBSCRIPTION_TIER]: stringType,
+    [CONFIGURATIONS_PAYMENTS_ENABLED]: booleanType,
+    [CONFIGURATIONS_STRIPE_CONNECTED_ACCOUNT_ID]: stringType,
+    [CONFIGURATIONS_CONTEXT_MENU_ENABLED]: booleanType,
+    [CONFIGURATIONS_COMMENTS_ENABLED]: booleanType,
+    [CONFIGURATIONS_SIDEBAR_SHOW_ALL_CATEGORIES_ENABLED]: booleanType,
+    [CONFIGURATIONS_VIDEO_AUTOPLAY_ENABLED]: booleanType,
+    [CONFIGURATIONS_VIDEO_PLAY_TRACKING_DELAY_SECONDS]: integerType,
+    [CONFIGURATIONS_SCHEDULED_POSTS_ENABLED]: booleanType,
+    [CONFIGURATIONS_POST_CATEGORY_REQUIRED_ENABLED]: booleanType,
+    [CONFIGURATIONS_POST_ADDRESSING_REQUIRED_ENABLED]: booleanType,
+    [CONFIGURATIONS_ACCEPTED_MEDIA_MIMETYPES]: stringType,
     [PROVIDERS_APP_URL_ON_APP_STORE]: stringType,
     [PROVIDERS_APP_URL_ON_GOOGLE_PLAY]: stringType,
     [PROVIDERS_FACEBOOK_SIGNIN_ENABLED]: stringType,
@@ -330,4 +360,7 @@ export const DATA_TYPES = {
     [WEBMASTER_META_DESCRIPTION]: stringType,
     [STATIC_ENVIRONMENT]: stringType,
     [STATIC_STACKID]: stringType,
+    [STATIC_STRIPE_PUBLIC_KEY]: stringType,
+    [CONFIGURATIONS_POST_USER_ADDRESSING_ENABLED]: booleanType,
+    [CONFIGURATIONS_CONTACT_API_ENABLED]: booleanType,
 };

package/lib/esm/constants/Routes.d.ts

@@ -23,7 +23,12 @@ export declare const USER_PROFILE_CONNECTIONS_REQUESTS_ROUTE_NAME = "user_connec
 export declare const USER_PROFILE_CONNECTIONS_REQUESTS_SENT_ROUTE_NAME = "user_connections_requests_sent";
 export declare const USER_PROFILE_CATEGORIES_ROUTE_NAME = "user_categories";
 export declare const USER_PROFILE_FOLLOWED_POSTS_ROUTE_NAME = "user_followed_posts";
+export declare const USER_PROFILE_SCHEDULED_POSTS_ROUTE_NAME = "user_scheduled_posts";
+export declare const USER_PROFILE_SCHEDULED_DISCUSSIONS_ROUTE_NAME = "user_scheduled_discussions";
 export declare const USER_PROFILE_FOLLOWED_DISCUSSIONS_ROUTE_NAME = "user_followed_discussions";
+export declare const USER_PAYMENTS_HISTORY_ORDERS_ROUTE_NAME = "user_payments_history_orders";
+export declare const USER_PAYMENTS_ORDER_PDF_ROUTE_NAME = "user_payments_order_pdf";
+export declare const USER_PAYMENT_METHODS_ROUTE_NAME = "user_payment_methods";
 export declare const LOYALTY_ROUTE_NAME = "loyalty";
 export declare const INCUBATOR_ROUTE_NAME = "incubator";
 export declare const SIGNIN_ROUTE_NAME = "signin";
@@ -50,6 +55,7 @@ export declare const EVENTS_SUGGESTED_ROUTE_NAME = "events_suggested";
 export declare const EVENTS_SUBSCRIBED_ROUTE_NAME = "events_subscribed";
 export declare const EVENTS_HIGHLIGHT_ROUTE_NAME = "events_highlight";
 export declare const LIVESTREAM_ROUTE_NAME = "live";
+export declare const CHECKOUT_PAYMENT = "checkout_payment";
 /**
  * Default Routes
  * @type {{[p: string]: string, '[POST_ROUTE_NAME]': string, '[INCUBATOR_ROUTE_NAME]': string, '[LOYALTY_ROUTE_NAME]': string, '[USER_NOTIFICATION_ROUTE_NAME]': string, '[USER_PRIVATE_MESSAGES_ROUTE_NAME]': string, '[COMMENT_ROUTE_NAME]': string, '[DISCUSSION_ROUTE_NAME]': string, '[CATEGORIES_ROUTE_NAME]': string, '[USER_PROFILE_ROUTE_NAME]': string, '[CATEGORY_ROUTE_NAME]': string, '[USER_PROFILE_SETTINGS_ROUTE_NAME]': string, '[STATUS_ROUTE_NAME]': string}}

package/lib/esm/constants/Routes.js

@@ -23,7 +23,12 @@ export const USER_PROFILE_CONNECTIONS_REQUESTS_ROUTE_NAME = 'user_connections_re
 export const USER_PROFILE_CONNECTIONS_REQUESTS_SENT_ROUTE_NAME = 'user_connections_requests_sent';
 export const USER_PROFILE_CATEGORIES_ROUTE_NAME = 'user_categories';
 export const USER_PROFILE_FOLLOWED_POSTS_ROUTE_NAME = 'user_followed_posts';
+export const USER_PROFILE_SCHEDULED_POSTS_ROUTE_NAME = 'user_scheduled_posts';
+export const USER_PROFILE_SCHEDULED_DISCUSSIONS_ROUTE_NAME = 'user_scheduled_discussions';
 export const USER_PROFILE_FOLLOWED_DISCUSSIONS_ROUTE_NAME = 'user_followed_discussions';
+export const USER_PAYMENTS_HISTORY_ORDERS_ROUTE_NAME = 'user_payments_history_orders';
+export const USER_PAYMENTS_ORDER_PDF_ROUTE_NAME = 'user_payments_order_pdf';
+export const USER_PAYMENT_METHODS_ROUTE_NAME = 'user_payment_methods';
 export const LOYALTY_ROUTE_NAME = 'loyalty';
 export const INCUBATOR_ROUTE_NAME = 'incubator';
 export const SIGNIN_ROUTE_NAME = 'signin';
@@ -50,6 +55,7 @@ export const EVENTS_SUGGESTED_ROUTE_NAME = 'events_suggested';
 export const EVENTS_SUBSCRIBED_ROUTE_NAME = 'events_subscribed';
 export const EVENTS_HIGHLIGHT_ROUTE_NAME = 'events_highlight';
 export const LIVESTREAM_ROUTE_NAME = 'live';
+export const CHECKOUT_PAYMENT = 'checkout_payment';
 /**
  * Default Routes
  * @type {{[p: string]: string, '[POST_ROUTE_NAME]': string, '[INCUBATOR_ROUTE_NAME]': string, '[LOYALTY_ROUTE_NAME]': string, '[USER_NOTIFICATION_ROUTE_NAME]': string, '[USER_PRIVATE_MESSAGES_ROUTE_NAME]': string, '[COMMENT_ROUTE_NAME]': string, '[DISCUSSION_ROUTE_NAME]': string, '[CATEGORIES_ROUTE_NAME]': string, '[USER_PROFILE_ROUTE_NAME]': string, '[CATEGORY_ROUTE_NAME]': string, '[USER_PROFILE_SETTINGS_ROUTE_NAME]': string, '[STATUS_ROUTE_NAME]': string}}
@@ -75,7 +81,12 @@ export const defaultRoutes = {
     [USER_PROFILE_CONNECTIONS_REQUESTS_SENT_ROUTE_NAME]: '/user/:id/connections/requests/sent/',
     [USER_PROFILE_CATEGORIES_ROUTE_NAME]: '/user/:id/categories/',
     [USER_PROFILE_FOLLOWED_POSTS_ROUTE_NAME]: '/user/:id/posts/followed/',
+    [USER_PROFILE_SCHEDULED_POSTS_ROUTE_NAME]: '/user/:id/posts/scheduled/',
     [USER_PROFILE_FOLLOWED_DISCUSSIONS_ROUTE_NAME]: '/user/:id/discussions/followed/',
+    [USER_PROFILE_SCHEDULED_DISCUSSIONS_ROUTE_NAME]: '/user/:id/discussions/scheduled/',
+    [USER_PAYMENTS_HISTORY_ORDERS_ROUTE_NAME]: '/user/:id/:username/history_orders/',
+    [USER_PAYMENTS_ORDER_PDF_ROUTE_NAME]: '/user/:id/:username/order/:pid/pdf/',
+    [USER_PAYMENT_METHODS_ROUTE_NAME]: '/user/:id/:username/payment_methods/',
     [LOYALTY_ROUTE_NAME]: '/loyalty/',
     [INCUBATOR_ROUTE_NAME]: '/incubator/:id/',
     [SIGNIN_ROUTE_NAME]: '/signin/',
@@ -102,4 +113,5 @@ export const defaultRoutes = {
     [COURSE_LESSON_COMMENTS_ROUTE_NAME]: '/course/:id/:slug/section/:section_id/lesson/:lesson_id/comments',
     [COURSE_LESSON_EDIT_ROUTE_NAME]: '/course/:id/:slug/section/:section_id/lesson/:lesson_id/edit',
     [LIVESTREAM_ROUTE_NAME]: '/live/:slug/',
+    [CHECKOUT_PAYMENT]: '/checkout/:content_type/:content_id/price/:price_id',
 };

package/lib/esm/hooks/useFetchMenuFooter.d.ts

@@ -0,0 +1,5 @@
+import { SCCustomMenu, SCCustomMenuType } from '@selfcommunity/types';
+export default function useFetchMenuFooter(id: SCCustomMenu, menu?: SCCustomMenuType | null): {
+    _menu: SCCustomMenuType;
+    loading: boolean;
+};

package/lib/esm/hooks/useFetchMenuFooter.js

@@ -0,0 +1,33 @@
+import { CustomMenuService } from '@selfcommunity/api-services';
+import { Logger } from '@selfcommunity/utils';
+import { useCallback, useEffect, useState } from 'react';
+import { SCOPE_SC_CORE } from '../constants/Errors';
+export default function useFetchMenuFooter(id, menu = null) {
+    // STATES
+    const [_menu, setMenu] = useState(menu);
+    const [loading, setLoading] = useState(!menu);
+    /**
+     * Fetches custom pages
+     */
+    const fetchMenu = useCallback(() => {
+        setLoading(true);
+        CustomMenuService.getASpecificCustomMenu(id)
+            .then((menu) => {
+            setMenu(menu);
+        })
+            .catch((error) => {
+            Logger.error(SCOPE_SC_CORE, error);
+        })
+            .then(() => setLoading(false));
+    }, []);
+    /**
+     * On mount, fetches legal and custom pages
+     */
+    useEffect(() => {
+        if (menu) {
+            return;
+        }
+        fetchMenu();
+    }, [id]);
+    return { _menu, loading };
+}

package/lib/esm/hooks/useSCFeature.d.ts

@@ -0,0 +1,22 @@
+import { SCFeatureName } from '@selfcommunity/types';
+/**
+ * Custom hook to check if the feature is enabled
+ * @param featureName - feature name
+ * @returns boolean - true if the feature is in the list of features
+ *
+ * Ex.
+ *   const isTaggingEnabled = useSCFeatureEnabled(SCFeatureName.TAGGING);
+ */
+export declare function useSCFeatureEnabled(featureName: SCFeatureName): boolean;
+/**
+ * Custom hook to check if a list of features are enabled
+ * @param featureNames - feature names
+ * @returns boolean - true if all features are in the features list
+ *
+ * Ex.
+ *   const hasRequiredFeatures = useSCFeaturesEnabled([
+ *     SCFeatureName.TAGGING,
+ *     SCFeatureName.GROUPING
+ *   ]);
+ */
+export declare function useSCFeaturesEnabled(featureNames: SCFeatureName[]): boolean;

package/lib/esm/hooks/useSCFeature.js

@@ -0,0 +1,33 @@
+import { useMemo } from 'react';
+import { useSCPreferences } from '../components/provider/SCPreferencesProvider';
+/**
+ * Custom hook to check if the feature is enabled
+ * @param featureName - feature name
+ * @returns boolean - true if the feature is in the list of features
+ *
+ * Ex.
+ *   const isTaggingEnabled = useSCFeatureEnabled(SCFeatureName.TAGGING);
+ */
+export function useSCFeatureEnabled(featureName) {
+    const { features } = useSCPreferences();
+    return useMemo(() => {
+        return Boolean(features && features.includes(featureName));
+    }, [features, featureName]);
+}
+/**
+ * Custom hook to check if a list of features are enabled
+ * @param featureNames - feature names
+ * @returns boolean - true if all features are in the features list
+ *
+ * Ex.
+ *   const hasRequiredFeatures = useSCFeaturesEnabled([
+ *     SCFeatureName.TAGGING,
+ *     SCFeatureName.GROUPING
+ *   ]);
+ */
+export function useSCFeaturesEnabled(featureNames) {
+    const { features } = useSCPreferences();
+    return useMemo(() => {
+        return Boolean(features && featureNames.every((name) => features.includes(name)));
+    }, [features, featureNames]);
+}

package/lib/esm/hooks/useSCFetchCategory.d.ts

@@ -18,4 +18,5 @@ export default function useSCFetchCategory({ id, category, cacheStrategy, }: {
     scCategory: SCCategoryType;
     setSCCategory: import("react").Dispatch<import("react").SetStateAction<SCCategoryType>>;
     error: string;
+    refreshCategory: () => void;
 };

package/lib/esm/hooks/useSCFetchCategory.js

@@ -40,6 +40,23 @@ export default function useSCFetchCategory({ id = null, category = null, cacheSt
             return Promise.resolve(res.data);
         });
     }, [__categoryId]);
+    /**
+     * Refresh category
+     */
+    const refreshCategory = useMemo(() => () => {
+        fetchCategory()
+            .then((obj) => {
+            const _c = authUserId ? obj : objectWithoutProperties(obj, ['followed']);
+            setSCCategory(_c);
+            LRUCache.set(__categoryCacheKey, _c);
+        })
+            .catch((err) => {
+            LRUCache.delete(__categoryCacheKey);
+            setError(`Error on refresh category with id ${id}`);
+            Logger.error(SCOPE_SC_CORE, `Error on refresh category with id ${id}`);
+            Logger.error(SCOPE_SC_CORE, err.message);
+        });
+    }, [__categoryId, setSCCategory, __categoryCacheKey]);
     /**
      * If id attempt to get the category by id
      */
@@ -66,5 +83,5 @@ export default function useSCFetchCategory({ id = null, category = null, cacheSt
             LRUCache.set(__categoryCacheKey, _c);
         }
     }, [category]);
-    return { scCategory, setSCCategory, error };
+    return { scCategory, setSCCategory, error, refreshCategory };
 }

package/lib/esm/hooks/useSCFetchCourse.js

@@ -46,6 +46,21 @@ export default function useSCFetchCourse({ id = null, course = null, cacheStrate
             return Promise.resolve(res.data);
         });
     }, []);
+    /**
+     * Refresh course
+     */
+    const refreshCourse = useMemo(() => () => {
+        fetchCourse(id)
+            .then((e) => {
+            setSCCourse(e);
+        })
+            .catch((err) => {
+            LRUCache.delete(__courseCacheKey);
+            setError(`Error on refresh course with id ${id}`);
+            Logger.error(SCOPE_SC_CORE, `Error on refresh course with id ${id}`);
+            Logger.error(SCOPE_SC_CORE, err.message);
+        });
+    }, [id, __courseCacheKey, setSCCourse]);
     /**
      * If id attempt to get the course by id
      */
@@ -74,20 +89,5 @@ export default function useSCFetchCourse({ id = null, course = null, cacheStrate
             setSCCourse(course);
         }
     }, [course, authUserId]);
-    /**
-     * Refreshes course data from the network
-     */
-    const refreshCourse = useCallback(() => {
-        if (id) {
-            fetchCourse(id)
-                .then((e) => {
-                setSCCourse(e);
-            })
-                .catch((err) => {
-                setError(`Failed to refresh course data: ${err.message}`);
-                Logger.error(SCOPE_SC_CORE, err.message);
-            });
-        }
-    }, [id, fetchCourse]);
     return { scCourse, setSCCourse, error, refreshCourse };
 }

package/lib/esm/hooks/useSCFetchEvent.d.ts

@@ -19,4 +19,5 @@ export default function useSCFetchEvent({ id, event, autoSubscribe, cacheStrateg
     scEvent: SCEventType;
     setSCEvent: (e: SCEventType) => void;
     error: string;
+    refreshEvent: () => () => void;
 };

package/lib/esm/hooks/useSCFetchEvent.js

@@ -66,6 +66,21 @@ export default function useSCFetchEvent({ id = null, event = null, autoSubscribe
             return Promise.resolve(res.data);
         });
     }, []);
+    /**
+     * Refresh event
+     */
+    const refreshEvent = useMemo(() => () => () => {
+        fetchEvent(id)
+            .then((e) => {
+            setSCEvent(e);
+        })
+            .catch((err) => {
+            LRUCache.delete(__eventCacheKey);
+            setError(`Error on refresh event with id ${id}`);
+            Logger.error(SCOPE_SC_CORE, `Error on refresh event with id ${id}`);
+            Logger.error(SCOPE_SC_CORE, err.message);
+        });
+    }, [id, setSCEvent, __eventCacheKey]);
     /**
      * If id attempt to get the event by id
      */
@@ -88,5 +103,5 @@ export default function useSCFetchEvent({ id = null, event = null, autoSubscribe
             setSCEvent(event);
         }
     }, [event, authUserId]);
-    return { scEvent, setSCEvent, error };
+    return { scEvent, setSCEvent, error, refreshEvent };
 }

package/lib/esm/hooks/useSCFetchGroup.d.ts

@@ -17,4 +17,5 @@ export default function useSCFetchGroup({ id, group, cacheStrategy, }: {
     scGroup: SCGroupType;
     setSCGroup: (group: SCGroupType) => void;
     error: string;
+    refreshGroup: () => void;
 };

package/lib/esm/hooks/useSCFetchGroup.js

@@ -45,6 +45,21 @@ export default function useSCFetchGroup({ id = null, group = null, cacheStrategy
             return Promise.resolve(res.data);
         });
     }, [__groupId]);
+    /**
+     * Refresh group
+     */
+    const refreshGroup = useMemo(() => () => {
+        fetchGroup()
+            .then((obj) => {
+            setSCGroup(obj);
+        })
+            .catch((err) => {
+            LRUCache.delete(__groupCacheKey);
+            setError(`Error on refresh group with id ${id}`);
+            Logger.error(SCOPE_SC_CORE, `Error on refresh group with id ${id}`);
+            Logger.error(SCOPE_SC_CORE, err.message);
+        });
+    }, [__groupCacheKey, setSCGroup]);
     /**
      * If id attempt to get the group by id
      */
@@ -67,5 +82,5 @@ export default function useSCFetchGroup({ id = null, group = null, cacheStrategy
             setSCGroup(group);
         }
     }, [group, authUserId]);
-    return { scGroup, setSCGroup, error };
+    return { scGroup, setSCGroup, error, refreshGroup };
 }

package/lib/esm/hooks/useSCFetchPaymentOrder.d.ts

@@ -0,0 +1,20 @@
+import { SCPaymentOrder } from '@selfcommunity/types';
+import { CacheStrategies } from '@selfcommunity/utils';
+/**
+ :::info
+ This custom hook is used to fetch a payment order.
+ :::
+ * @param object
+ * @param object.id
+ * @param object.paymentOrder
+ * @param object.cacheStrategy
+ */
+export default function useSCFetchPaymentOrder({ id, paymentOrder, cacheStrategy, }: {
+    id?: number | string;
+    paymentOrder?: SCPaymentOrder;
+    cacheStrategy?: CacheStrategies;
+}): {
+    scPaymentOrder: SCPaymentOrder;
+    setSCPaymentOrder: (c: SCPaymentOrder) => void;
+    error: string;
+};

package/lib/esm/hooks/useSCFetchPaymentOrder.js

@@ -0,0 +1,67 @@
+import { Endpoints, http } from '@selfcommunity/api-services';
+import { CacheStrategies, Logger, LRUCache } from '@selfcommunity/utils';
+import { useCallback, useEffect, useMemo, useState } from 'react';
+import { useDeepCompareEffectNoCheck } from 'use-deep-compare-effect';
+import { useSCUser } from '../components/provider/SCUserProvider';
+import { getPaymentOrderObjectCacheKey } from '../constants/Cache';
+import { SCOPE_SC_CORE } from '../constants/Errors';
+/**
+ :::info
+ This custom hook is used to fetch a payment order.
+ :::
+ * @param object
+ * @param object.id
+ * @param object.paymentOrder
+ * @param object.cacheStrategy
+ */
+export default function useSCFetchPaymentOrder({ id = null, paymentOrder = null, cacheStrategy = CacheStrategies.NETWORK_ONLY, }) {
+    const __paymentOrderId = useMemo(() => (paymentOrder === null || paymentOrder === void 0 ? void 0 : paymentOrder.id) || id, [paymentOrder, id]);
+    // CONTEXT
+    const scUserContext = useSCUser();
+    const authUserId = useMemo(() => { var _a; return ((_a = scUserContext.user) === null || _a === void 0 ? void 0 : _a.id) || null; }, [scUserContext.user]);
+    // CACHE
+    const __paymentOrderCacheKey = useMemo(() => getPaymentOrderObjectCacheKey(__paymentOrderId), [__paymentOrderId]);
+    const [scPaymentOrder, setScPaymentOrder] = useState(cacheStrategy !== CacheStrategies.NETWORK_ONLY ? LRUCache.get(__paymentOrderCacheKey, paymentOrder) : null);
+    const [error, setError] = useState(null);
+    const setSCPaymentOrder = useCallback((c) => {
+        setScPaymentOrder(c);
+        LRUCache.set(__paymentOrderCacheKey, c);
+    }, [setScPaymentOrder, __paymentOrderCacheKey]);
+    /**
+     * Memoized fetch order
+     */
+    const fetchPaymentOrder = useMemo(() => (id) => {
+        return http
+            .request({
+            url: Endpoints.GetPaymentOrder.url({ id }),
+            method: Endpoints.GetPaymentOrder.method,
+        })
+            .then((res) => {
+            if (res.status >= 300) {
+                return Promise.reject(res);
+            }
+            return Promise.resolve(res.data);
+        });
+    }, []);
+    /**
+     * If id attempt to get the course by id
+     */
+    useEffect(() => {
+        if (id !== null && id !== undefined && !paymentOrder) {
+            fetchPaymentOrder(id)
+                .then((e) => {
+                setSCPaymentOrder(e);
+            })
+                .catch((err) => {
+                LRUCache.delete(__paymentOrderCacheKey);
+                Logger.error(SCOPE_SC_CORE, err.message);
+            });
+        }
+    }, [id, paymentOrder, authUserId]);
+    useDeepCompareEffectNoCheck(() => {
+        if (paymentOrder) {
+            setSCPaymentOrder(paymentOrder);
+        }
+    }, [paymentOrder, authUserId]);
+    return { scPaymentOrder, setSCPaymentOrder, error };
+}

package/lib/esm/hooks/useSCFetchPaymentProduct.d.ts

@@ -0,0 +1,20 @@
+import { SCPaymentProduct } from '@selfcommunity/types';
+import { CacheStrategies } from '@selfcommunity/utils';
+/**
+ :::info
+ This custom hook is used to fetch a payment product.
+ :::
+ * @param object
+ * @param object.id
+ * @param object.paymentProduct
+ * @param object.cacheStrategy
+ */
+export default function useSCFetchPaymentProduct({ id, paymentProduct, cacheStrategy, }: {
+    id?: number | string;
+    paymentProduct?: SCPaymentProduct;
+    cacheStrategy?: CacheStrategies;
+}): {
+    scPaymentProduct: SCPaymentProduct;
+    setSCPaymentProduct: (c: SCPaymentProduct) => void;
+    error: string;
+};

package/lib/esm/hooks/useSCFetchPaymentProduct.js

@@ -0,0 +1,67 @@
+import { Endpoints, http } from '@selfcommunity/api-services';
+import { CacheStrategies, Logger, LRUCache } from '@selfcommunity/utils';
+import { useCallback, useEffect, useMemo, useState } from 'react';
+import { useDeepCompareEffectNoCheck } from 'use-deep-compare-effect';
+import { useSCUser } from '../components/provider/SCUserProvider';
+import { getPaymentProductObjectCacheKey } from '../constants/Cache';
+import { SCOPE_SC_CORE } from '../constants/Errors';
+/**
+ :::info
+ This custom hook is used to fetch a payment product.
+ :::
+ * @param object
+ * @param object.id
+ * @param object.paymentProduct
+ * @param object.cacheStrategy
+ */
+export default function useSCFetchPaymentProduct({ id = null, paymentProduct = null, cacheStrategy = CacheStrategies.NETWORK_ONLY, }) {
+    const __paymentProductId = useMemo(() => (paymentProduct === null || paymentProduct === void 0 ? void 0 : paymentProduct.id) || id, [paymentProduct, id]);
+    // CONTEXT
+    const scUserContext = useSCUser();
+    const authUserId = useMemo(() => { var _a; return ((_a = scUserContext.user) === null || _a === void 0 ? void 0 : _a.id) || null; }, [scUserContext.user]);
+    // CACHE
+    const __paymentProductCacheKey = useMemo(() => getPaymentProductObjectCacheKey(__paymentProductId), [__paymentProductId]);
+    const [scPaymentProduct, setScPaymentProduct] = useState(cacheStrategy !== CacheStrategies.NETWORK_ONLY ? LRUCache.get(__paymentProductCacheKey, paymentProduct) : null);
+    const [error, setError] = useState(null);
+    const setSCPaymentProduct = useCallback((c) => {
+        setScPaymentProduct(c);
+        LRUCache.set(__paymentProductCacheKey, c);
+    }, [setScPaymentProduct, __paymentProductCacheKey]);
+    /**
+     * Memoized fetch product
+     */
+    const fetchPaymentProduct = useMemo(() => (id) => {
+        return http
+            .request({
+            url: Endpoints.GetPaymentProduct.url({ id }),
+            method: Endpoints.GetPaymentProduct.method,
+        })
+            .then((res) => {
+            if (res.status >= 300) {
+                return Promise.reject(res);
+            }
+            return Promise.resolve(res.data);
+        });
+    }, []);
+    /**
+     * If id attempt to get the course by id
+     */
+    useEffect(() => {
+        if (id !== null && id !== undefined && !paymentProduct) {
+            fetchPaymentProduct(id)
+                .then((e) => {
+                setSCPaymentProduct(e);
+            })
+                .catch((err) => {
+                LRUCache.delete(__paymentProductCacheKey);
+                Logger.error(SCOPE_SC_CORE, err.message);
+            });
+        }
+    }, [id, paymentProduct, authUserId]);
+    useDeepCompareEffectNoCheck(() => {
+        if (paymentProduct) {
+            setSCPaymentProduct(paymentProduct);
+        }
+    }, [paymentProduct, authUserId]);
+    return { scPaymentProduct, setSCPaymentProduct, error };
+}

package/lib/esm/hooks/useSCFetchUsers.d.ts

@@ -0,0 +1,21 @@
+import { SCUserAutocompleteType } from '@selfcommunity/types';
+/**
+ :::info
+ This custom hook is used to fetch users.
+   
+ :::tip Context can be consumed in this way:
+
+ ```jsx
+ const {users, isLoading} = useSCFetchUsers();
+ ```
+ :::
+ * @param props
+ */
+declare const useSCFetchUsers: (props?: {
+    search: string;
+    exclude?: string;
+}) => {
+    users: SCUserAutocompleteType[];
+    isLoading: boolean;
+};
+export default useSCFetchUsers;

package/lib/esm/hooks/useSCFetchUsers.js

@@ -0,0 +1,48 @@
+import { __awaiter } from "tslib";
+import { useEffect, useState } from 'react';
+import { SCOPE_SC_CORE } from '../constants/Errors';
+import { Endpoints, http } from '@selfcommunity/api-services';
+import { Logger } from '@selfcommunity/utils';
+/**
+ :::info
+ This custom hook is used to fetch users.
+   
+ :::tip Context can be consumed in this way:
+
+ ```jsx
+ const {users, isLoading} = useSCFetchUsers();
+ ```
+ :::
+ * @param props
+ */
+const useSCFetchUsers = (props) => {
+    const { search = '', exclude = '' } = props || {};
+    const [data, setData] = useState({ users: [], isLoading: false });
+    const fetchUsers = (next = Endpoints.UserAutocomplete.url(), searchParam, excludeParam) => __awaiter(void 0, void 0, void 0, function* () {
+        const response = yield http.request({
+            url: next,
+            method: Endpoints.UserAutocomplete.method,
+            params: Object.assign({ search: searchParam }, (excludeParam && { exclude: excludeParam })),
+        });
+        const result = response.data;
+        if (result.next) {
+            return result.results.concat(yield fetchUsers(result.next, searchParam, excludeParam));
+        }
+        return result.results;
+    });
+    useEffect(() => {
+        if (!search)
+            return;
+        fetchUsers(undefined, search, exclude)
+            .then((users) => {
+            setData({ users, isLoading: false });
+        })
+            .catch((error) => {
+            console.error(error);
+            Logger.error(SCOPE_SC_CORE, 'Unable to retrieve users');
+            setData((prev) => (Object.assign(Object.assign({}, prev), { isLoading: false })));
+        });
+    }, [search, exclude]);
+    return data;
+};
+export default useSCFetchUsers;

package/lib/esm/hooks/useSCJoinedCoursesManager.d.ts

@@ -30,7 +30,7 @@ export default function useSCJoinedCoursesManager(user?: SCUserType): {
     isLoading: (v: number | {
         id: number;
     }) => boolean;
-    join: (course: SCCourseType, userId?: number) => Promise<any>;
+    join: (course: SCCourseType) => Promise<any>;
     leave: (course: SCCourseType) => Promise<any>;
     joinStatus: (course: SCCourseType) => string;
     refresh: () => void;