@iblai/web-utils 1.6.5 → 1.6.7

package/dist/index.js

@@ -442,6 +442,14 @@ const BASE_CONFIG = {
             description: "Default mentor to open on the platform",
             type: "string",
         },
+        /* {
+          slug: "monetization_base_path",
+          label: "Public Monetization Base Path",
+          defaultValue: "https://ibl.ai/buy/",
+          description:
+            "Base URL for public paywall product pages. The product unique ID will be appended to this path.",
+          type: "string",
+        }, */
     ],
 };
 // SkillsAI platform configuration
@@ -2882,6 +2890,12 @@ async function validateJwtToken(storageService) {
         if (!edxJwtToken || !userData) {
             return false;
         }
+        // Skip JWT validation if token is not in JWT format (e.g. opaque LTI tokens)
+        const parts = edxJwtToken.split(".");
+        if (parts.length !== 3) {
+            console.warn("[AuthProvider] Token is not a valid JWT format, skipping validation");
+            return false;
+        }
         const decodedToken = jwtDecode(edxJwtToken);
         const userDataObj = JSON.parse(userData);
         // Compare user_id from token with user_id from user_data
@@ -3362,6 +3376,7 @@ function TenantProvider({ children, fallback, onAuthSuccess, onAuthFailure, curr
                         "/roles/",
                         "/policies/",
                         "/usergroups/",
+                        "/watchedgroups/",
                     ],
                 },
             }).unwrap();
@@ -15583,6 +15598,15 @@ createApi({
             }),
             invalidatesTags: ['paywallConfig', 'paywalls'],
         }),
+        updatePaywall: builder.mutation({
+            query: ({ platform_key, item_type, item_id, ...body }) => ({
+                url: MONETIZATION_ENDPOINTS.PAYWALL_CONFIG.path(platform_key, item_type, item_id),
+                service: MONETIZATION_ENDPOINTS.PAYWALL_CONFIG.service,
+                method: 'PUT',
+                body: JSON.stringify(body),
+            }),
+            invalidatesTags: ['paywallConfig', 'paywalls'],
+        }),
         disablePaywall: builder.mutation({
             query: ({ platform_key, item_type, item_id }) => ({
                 url: MONETIZATION_ENDPOINTS.PAYWALL_CONFIG.path(platform_key, item_type, item_id),
@@ -15642,6 +15666,9 @@ createApi({
                 url: MONETIZATION_ENDPOINTS.ACCESS_CHECK.path(platform_key, item_type, item_id),
                 service: MONETIZATION_ENDPOINTS.ACCESS_CHECK.service,
                 method: 'GET',
+                // Treat paywall-related 4xx (e.g. 402 Payment Required) as success so the
+                // response body (has_access, pricing, reason, …) reaches the caller as `data`.
+                validateStatus: (response) => response.ok || [402].includes(response.status),
             }),
             providesTags: ['accessCheck'],
         }),
@@ -19104,6 +19131,231 @@ createApi({
     }),
 });
 
+const WATCHED_GROUPS_REDUCER_PATH = 'watchedGroupsApiSlice';
+const WATCHED_GROUPS_QUERY_KEYS = {
+    WATCHED_GROUPS: 'WATCHED_GROUPS',
+    WATCHED_GROUP: 'WATCHED_GROUP',
+    WATCHED_USERS: 'WATCHED_USERS',
+    WATCHERS: 'WATCHERS',
+    WATCHER: 'WATCHER',
+};
+const WATCHED_GROUPS_ENDPOINTS = {
+    LIST_WATCHED_GROUPS: {
+        service: SERVICES.DM,
+        path: () => `/api/core/watched-groups/`,
+    },
+    CREATE_WATCHED_GROUP: {
+        service: SERVICES.DM,
+        path: () => `/api/core/watched-groups/`,
+    },
+    GET_WATCHED_GROUP: {
+        service: SERVICES.DM,
+        path: (id) => `/api/core/watched-groups/${id}/`,
+    },
+    UPDATE_WATCHED_GROUP: {
+        service: SERVICES.DM,
+        path: (id) => `/api/core/watched-groups/${id}/`,
+    },
+    DELETE_WATCHED_GROUP: {
+        service: SERVICES.DM,
+        path: (id) => `/api/core/watched-groups/${id}/`,
+    },
+    LIST_WATCHED_USERS: {
+        service: SERVICES.DM,
+        path: (watchedGroupPk) => `/api/core/watched-groups/${watchedGroupPk}/watched-users/`,
+    },
+    ADD_WATCHED_USER: {
+        service: SERVICES.DM,
+        path: (watchedGroupPk) => `/api/core/watched-groups/${watchedGroupPk}/watched-users/`,
+    },
+    REMOVE_WATCHED_USER: {
+        service: SERVICES.DM,
+        path: (watchedGroupPk, id) => `/api/core/watched-groups/${watchedGroupPk}/watched-users/${id}/`,
+    },
+    LIST_WATCHERS: {
+        service: SERVICES.DM,
+        path: (watchedGroupPk) => `/api/core/watched-groups/${watchedGroupPk}/watchers/`,
+    },
+    ADD_WATCHER: {
+        service: SERVICES.DM,
+        path: (watchedGroupPk) => `/api/core/watched-groups/${watchedGroupPk}/watchers/`,
+    },
+    GET_WATCHER: {
+        service: SERVICES.DM,
+        path: (watchedGroupPk, id) => `/api/core/watched-groups/${watchedGroupPk}/watchers/${id}/`,
+    },
+    UPDATE_WATCHER: {
+        service: SERVICES.DM,
+        path: (watchedGroupPk, id) => `/api/core/watched-groups/${watchedGroupPk}/watchers/${id}/`,
+    },
+    DELETE_WATCHER: {
+        service: SERVICES.DM,
+        path: (watchedGroupPk, id) => `/api/core/watched-groups/${watchedGroupPk}/watchers/${id}/`,
+    },
+};
+
+createApi({
+    reducerPath: WATCHED_GROUPS_REDUCER_PATH,
+    baseQuery: iblFetchBaseQuery,
+    tagTypes: [
+        WATCHED_GROUPS_QUERY_KEYS.WATCHED_GROUPS,
+        WATCHED_GROUPS_QUERY_KEYS.WATCHED_GROUP,
+        WATCHED_GROUPS_QUERY_KEYS.WATCHED_USERS,
+        WATCHED_GROUPS_QUERY_KEYS.WATCHERS,
+        WATCHED_GROUPS_QUERY_KEYS.WATCHER,
+    ],
+    endpoints: (builder) => ({
+        getWatchedGroups: builder.query({
+            query: (args) => ({
+                url: WATCHED_GROUPS_ENDPOINTS.LIST_WATCHED_GROUPS.path(),
+                service: WATCHED_GROUPS_ENDPOINTS.LIST_WATCHED_GROUPS.service,
+                method: 'GET',
+                params: args === null || args === void 0 ? void 0 : args.params,
+            }),
+            providesTags: [WATCHED_GROUPS_QUERY_KEYS.WATCHED_GROUPS],
+        }),
+        getWatchedGroup: builder.query({
+            query: ({ id, params }) => ({
+                url: WATCHED_GROUPS_ENDPOINTS.GET_WATCHED_GROUP.path(id),
+                service: WATCHED_GROUPS_ENDPOINTS.GET_WATCHED_GROUP.service,
+                method: 'GET',
+                params,
+            }),
+            providesTags: (_result, _error, { id }) => [
+                { type: WATCHED_GROUPS_QUERY_KEYS.WATCHED_GROUP, id },
+            ],
+        }),
+        createWatchedGroup: builder.mutation({
+            query: ({ body, params }) => ({
+                url: WATCHED_GROUPS_ENDPOINTS.CREATE_WATCHED_GROUP.path(),
+                service: WATCHED_GROUPS_ENDPOINTS.CREATE_WATCHED_GROUP.service,
+                method: 'POST',
+                body,
+                params,
+            }),
+            invalidatesTags: [WATCHED_GROUPS_QUERY_KEYS.WATCHED_GROUPS],
+        }),
+        updateWatchedGroup: builder.mutation({
+            query: ({ id, body, params }) => ({
+                url: WATCHED_GROUPS_ENDPOINTS.UPDATE_WATCHED_GROUP.path(id),
+                service: WATCHED_GROUPS_ENDPOINTS.UPDATE_WATCHED_GROUP.service,
+                method: 'PATCH',
+                body,
+                params,
+            }),
+            invalidatesTags: (_result, _error, { id }) => [
+                WATCHED_GROUPS_QUERY_KEYS.WATCHED_GROUPS,
+                { type: WATCHED_GROUPS_QUERY_KEYS.WATCHED_GROUP, id },
+            ],
+        }),
+        deleteWatchedGroup: builder.mutation({
+            query: ({ id, params }) => ({
+                url: WATCHED_GROUPS_ENDPOINTS.DELETE_WATCHED_GROUP.path(id),
+                service: WATCHED_GROUPS_ENDPOINTS.DELETE_WATCHED_GROUP.service,
+                method: 'DELETE',
+                params,
+            }),
+            invalidatesTags: [WATCHED_GROUPS_QUERY_KEYS.WATCHED_GROUPS],
+        }),
+        getWatchedUsers: builder.query({
+            query: ({ watchedGroupPk, params }) => ({
+                url: WATCHED_GROUPS_ENDPOINTS.LIST_WATCHED_USERS.path(watchedGroupPk),
+                service: WATCHED_GROUPS_ENDPOINTS.LIST_WATCHED_USERS.service,
+                method: 'GET',
+                params,
+            }),
+            providesTags: (_result, _error, { watchedGroupPk }) => [
+                { type: WATCHED_GROUPS_QUERY_KEYS.WATCHED_USERS, id: watchedGroupPk },
+            ],
+        }),
+        addWatchedUser: builder.mutation({
+            query: ({ watchedGroupPk, body, params }) => ({
+                url: WATCHED_GROUPS_ENDPOINTS.ADD_WATCHED_USER.path(watchedGroupPk),
+                service: WATCHED_GROUPS_ENDPOINTS.ADD_WATCHED_USER.service,
+                method: 'POST',
+                body,
+                params,
+            }),
+            invalidatesTags: (_result, _error, { watchedGroupPk }) => [
+                { type: WATCHED_GROUPS_QUERY_KEYS.WATCHED_USERS, id: watchedGroupPk },
+                { type: WATCHED_GROUPS_QUERY_KEYS.WATCHED_GROUP, id: watchedGroupPk },
+            ],
+        }),
+        removeWatchedUser: builder.mutation({
+            query: ({ watchedGroupPk, id, params }) => ({
+                url: WATCHED_GROUPS_ENDPOINTS.REMOVE_WATCHED_USER.path(watchedGroupPk, id),
+                service: WATCHED_GROUPS_ENDPOINTS.REMOVE_WATCHED_USER.service,
+                method: 'DELETE',
+                params,
+            }),
+            invalidatesTags: (_result, _error, { watchedGroupPk }) => [
+                { type: WATCHED_GROUPS_QUERY_KEYS.WATCHED_USERS, id: watchedGroupPk },
+                { type: WATCHED_GROUPS_QUERY_KEYS.WATCHED_GROUP, id: watchedGroupPk },
+            ],
+        }),
+        getWatchers: builder.query({
+            query: ({ watchedGroupPk, params }) => ({
+                url: WATCHED_GROUPS_ENDPOINTS.LIST_WATCHERS.path(watchedGroupPk),
+                service: WATCHED_GROUPS_ENDPOINTS.LIST_WATCHERS.service,
+                method: 'GET',
+                params,
+            }),
+            providesTags: (_result, _error, { watchedGroupPk }) => [
+                { type: WATCHED_GROUPS_QUERY_KEYS.WATCHERS, id: watchedGroupPk },
+            ],
+        }),
+        addWatcher: builder.mutation({
+            query: ({ watchedGroupPk, body, params }) => ({
+                url: WATCHED_GROUPS_ENDPOINTS.ADD_WATCHER.path(watchedGroupPk),
+                service: WATCHED_GROUPS_ENDPOINTS.ADD_WATCHER.service,
+                method: 'POST',
+                body,
+                params,
+            }),
+            invalidatesTags: (_result, _error, { watchedGroupPk }) => [
+                { type: WATCHED_GROUPS_QUERY_KEYS.WATCHERS, id: watchedGroupPk },
+                { type: WATCHED_GROUPS_QUERY_KEYS.WATCHED_GROUP, id: watchedGroupPk },
+            ],
+        }),
+        getWatcher: builder.query({
+            query: ({ watchedGroupPk, id, params }) => ({
+                url: WATCHED_GROUPS_ENDPOINTS.GET_WATCHER.path(watchedGroupPk, id),
+                service: WATCHED_GROUPS_ENDPOINTS.GET_WATCHER.service,
+                method: 'GET',
+                params,
+            }),
+            providesTags: (_result, _error, { watchedGroupPk, id }) => [
+                { type: WATCHED_GROUPS_QUERY_KEYS.WATCHER, id: `${watchedGroupPk}-${id}` },
+            ],
+        }),
+        updateWatcher: builder.mutation({
+            query: ({ watchedGroupPk, id, body, params }) => ({
+                url: WATCHED_GROUPS_ENDPOINTS.UPDATE_WATCHER.path(watchedGroupPk, id),
+                service: WATCHED_GROUPS_ENDPOINTS.UPDATE_WATCHER.service,
+                method: 'PATCH',
+                body,
+                params,
+            }),
+            invalidatesTags: (_result, _error, { watchedGroupPk, id }) => [
+                { type: WATCHED_GROUPS_QUERY_KEYS.WATCHERS, id: watchedGroupPk },
+                { type: WATCHED_GROUPS_QUERY_KEYS.WATCHER, id: `${watchedGroupPk}-${id}` },
+            ],
+        }),
+        deleteWatcher: builder.mutation({
+            query: ({ watchedGroupPk, id, params }) => ({
+                url: WATCHED_GROUPS_ENDPOINTS.DELETE_WATCHER.path(watchedGroupPk, id),
+                service: WATCHED_GROUPS_ENDPOINTS.DELETE_WATCHER.service,
+                method: 'DELETE',
+                params,
+            }),
+            invalidatesTags: (_result, _error, { watchedGroupPk }) => [
+                { type: WATCHED_GROUPS_QUERY_KEYS.WATCHERS, id: watchedGroupPk },
+                { type: WATCHED_GROUPS_QUERY_KEYS.WATCHED_GROUP, id: watchedGroupPk },
+            ],
+        }),
+    }),
+});
+
 function useMentorSettings({ mentorId, tenantKey, username, isPublicRoute, }) {
     var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p;
     const isLoggedIn = username !== ANONYMOUS_USERNAME;