@antscorp/antsomi-ui 1.3.5-beta.92 → 1.3.5-beta.921

package/es/services/Permission/index.js

@@ -0,0 +1,57 @@
+import axios from 'axios';
+import { get } from 'lodash';
+const permissionPath = '/api/permission/index';
+export const permissionService = {
+    getAccountList: async (config) => {
+        try {
+            const { domain, ...restOfConfig } = config;
+            const response = await axios({
+                method: 'GET',
+                url: `${domain}${permissionPath}`,
+                params: {
+                    type: 'list-account',
+                    ...restOfConfig,
+                },
+            });
+            return get(response, 'data.data.listAccountId', []);
+        }
+        catch (error) {
+            return Promise.reject(error);
+        }
+    },
+    checkIpAccess: async (config) => {
+        try {
+            const { domain, userId, accountId, token } = config;
+            const response = await axios({
+                method: 'GET',
+                url: `${domain}/api/ip-restriction/index`,
+                params: {
+                    type: 'check-ip-access',
+                    _user_id: userId,
+                    _account_id: accountId,
+                    _token: token,
+                },
+            });
+            return get(response, 'data.data.hasAccess', false);
+        }
+        catch (error) {
+            return Promise.reject(error);
+        }
+    },
+    requestAccess: async (config) => {
+        try {
+            const { domain, userId, accountId, token, message } = config;
+            return await axios.post(`${domain}/api/account/request-access`, { message: message || '' }, {
+                params: {
+                    _user_id: userId,
+                    _account_id: accountId,
+                    _token: token,
+                },
+            });
+            // return get(response, 'data.data.hasAccess', false);
+        }
+        catch (error) {
+            return Promise.reject(error);
+        }
+    },
+};

package/es/services/TemplateListing/index.d.ts

@@ -8,6 +8,7 @@ export type TGetCategoryListArgs = {
         objectTypes: TObjectType[];
         categoryCodes?: string[];
         publicLevel?: TPublicLevel;
+        channel?: number;
         getListType?: TGetListType;
     };
     auth: PayloadInfo;
@@ -28,6 +29,7 @@ export type TGetObjectTemplateListArgs = {
     } & PaginationRequest;
     auth: TServiceAuth;
 };
+export type TGetPublicObjectTemplateListArgs = Omit<TGetObjectTemplateListArgs, 'auth'>;
 export type TBulkUpdateObjectTemplateArgs = {
     params: {
         template_ids: number[];
@@ -57,9 +59,11 @@ export type TValidateObjectTemplateNameArgs = {
 export declare const templateListingServices: {
     category: {
         getList: ({ params, auth }: TGetCategoryListArgs) => Promise<TemplateCategory[]>;
+        getPublicList: ({ params, auth }: TGetCategoryListArgs) => Promise<TemplateCategory[]>;
     };
     objectTemplate: {
         getList: ({ params, auth, }: TGetObjectTemplateListArgs) => Promise<ResponseListing<ObjectTemplate>>;
+        getPublicList: ({ params, auth, }: TGetObjectTemplateListArgs) => Promise<ResponseListing<ObjectTemplate>>;
         getDetail: ({ params, auth }: TGetObjectTemplateDetailArgs) => Promise<ObjectTemplate>;
         create: ({ data, auth }: TCreateObjectTemplateArgs) => Promise<ObjectTemplate>;
         update: ({ data, auth }: TUpdateObjectTemplateArgs) => Promise<ObjectTemplate>;

package/es/services/TemplateListing/index.js

@@ -1,23 +1,3 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __rest = (this && this.__rest) || function (s, e) {
-    var t = {};
-    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
-        t[p] = s[p];
-    if (s != null && typeof Object.getOwnPropertySymbols === "function")
-        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
-            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
-                t[p[i]] = s[p[i]];
-        }
-    return t;
-};
 // Libraries
 import { get } from 'lodash';
 import isEmpty from 'lodash/isEmpty';
@@ -29,28 +9,61 @@ const TEMPLATE_CATEGORY_ROUTE = 'template-category/index';
 const OBJECT_TEMPLATE_ROUTE = 'object-template';
 export const templateListingServices = {
     category: {
-        getList: ({ params, auth }) => __awaiter(void 0, void 0, void 0, function* () {
+        getList: async ({ params, auth }) => {
             try {
-                const { objectTypes = [], categoryCodes, publicLevel, getListType } = params;
-                const response = yield axios({
+                const { objectTypes = [], categoryCodes, publicLevel, getListType, channel } = params;
+                const response = await axios({
                     method: 'GET',
                     url: `${auth.url}/${TEMPLATE_CATEGORY_ROUTE}`,
-                    params: Object.assign({ _token: auth.token, _user_id: auth.userId, _account_id: auth.accountId, objectTypes: objectTypes.join(','), publicLevel: publicLevel !== null && publicLevel !== void 0 ? publicLevel : 0, getListType }, (!isEmpty(categoryCodes) ? { categoryCodes: categoryCodes === null || categoryCodes === void 0 ? void 0 : categoryCodes.join(',') } : {})),
+                    params: {
+                        _token: auth.token,
+                        _user_id: auth.userId,
+                        _account_id: auth.accountId,
+                        objectTypes: objectTypes.join(','),
+                        publicLevel: publicLevel ?? 0,
+                        getListType,
+                        channel,
+                        ...(!isEmpty(categoryCodes) ? { categoryCodes: categoryCodes?.join(',') } : {}),
+                    },
+                });
+                return get(response, 'data.data', []);
+            }
+            catch (error) {
+                return Promise.reject(error);
+            }
+        },
+        getPublicList: async ({ params, auth }) => {
+            try {
+                const { objectTypes = [], categoryCodes, channel } = params;
+                const response = await axios({
+                    method: 'GET',
+                    url: `${auth.url}/${TEMPLATE_CATEGORY_ROUTE}/get-public`,
+                    params: {
+                        _token: auth.token,
+                        objectTypes: objectTypes.join(','),
+                        channel,
+                        ...(!isEmpty(categoryCodes) ? { categoryCodes: categoryCodes?.join(',') } : {}),
+                    },
                 });
                 return get(response, 'data.data', []);
             }
             catch (error) {
                 return Promise.reject(error);
             }
-        }),
+        },
     },
     objectTemplate: {
-        getList: ({ params, auth, }) => __awaiter(void 0, void 0, void 0, function* () {
+        getList: async ({ params, auth, }) => {
             try {
-                const response = yield axios({
+                const response = await axios({
                     method: 'GET',
                     url: `${auth.url}/${OBJECT_TEMPLATE_ROUTE}`,
-                    params: Object.assign({ _token: auth.token, _user_id: auth.userId, _account_id: auth.accountId }, params),
+                    params: {
+                        _token: auth.token,
+                        _user_id: auth.userId,
+                        _account_id: auth.accountId,
+                        ...params,
+                    },
                 });
                 const { entities, meta } = get(response, 'data.data', {});
                 return {
@@ -61,24 +74,48 @@ export const templateListingServices = {
             catch (error) {
                 return Promise.reject(error);
             }
-        }),
-        getDetail: ({ params, auth }) => __awaiter(void 0, void 0, void 0, function* () {
+        },
+        getPublicList: async ({ params, auth, }) => {
             try {
-                const { template_id } = params, restOfPrams = __rest(params, ["template_id"]);
-                const response = yield axios({
+                const response = await axios({
+                    method: 'GET',
+                    url: `${auth.url}/${OBJECT_TEMPLATE_ROUTE}/public/get-gallery-template-list`,
+                    params: {
+                        ...params,
+                    },
+                });
+                const { entities, meta } = get(response, 'data.data', {});
+                return {
+                    entities: entities.map(entity => new ObjectTemplate(entity)),
+                    meta,
+                };
+            }
+            catch (error) {
+                return Promise.reject(error);
+            }
+        },
+        getDetail: async ({ params, auth }) => {
+            try {
+                const { template_id, ...restOfPrams } = params;
+                const response = await axios({
                     method: 'GET',
                     url: `${auth.url}/${OBJECT_TEMPLATE_ROUTE}/${template_id}`,
-                    params: Object.assign({ _token: auth.token, _user_id: auth.userId, _account_id: auth.accountId }, restOfPrams),
+                    params: {
+                        _token: auth.token,
+                        _user_id: auth.userId,
+                        _account_id: auth.accountId,
+                        ...restOfPrams,
+                    },
                 });
                 return new ObjectTemplate(get(response, 'data.data', {}));
             }
             catch (error) {
                 return Promise.reject(error);
             }
-        }),
-        create: ({ data, auth }) => __awaiter(void 0, void 0, void 0, function* () {
+        },
+        create: async ({ data, auth }) => {
             try {
-                const response = yield axios({
+                const response = await axios({
                     method: 'POST',
                     url: `${auth.url}/${OBJECT_TEMPLATE_ROUTE}`,
                     params: {
@@ -93,11 +130,11 @@ export const templateListingServices = {
             catch (error) {
                 return Promise.reject(error);
             }
-        }),
-        update: ({ data, auth }) => __awaiter(void 0, void 0, void 0, function* () {
+        },
+        update: async ({ data, auth }) => {
             try {
-                const { template_id } = data, restOfData = __rest(data, ["template_id"]);
-                const response = yield axios({
+                const { template_id, ...restOfData } = data;
+                const response = await axios({
                     method: 'PUT',
                     url: `${auth.url}/${OBJECT_TEMPLATE_ROUTE}/${template_id}`,
                     params: {
@@ -112,10 +149,10 @@ export const templateListingServices = {
             catch (error) {
                 return Promise.reject(error);
             }
-        }),
-        bulkUpdate: ({ params, auth }) => __awaiter(void 0, void 0, void 0, function* () {
+        },
+        bulkUpdate: async ({ params, auth }) => {
             try {
-                const response = yield axios({
+                const response = await axios({
                     method: 'POST',
                     url: `${auth.url}/${OBJECT_TEMPLATE_ROUTE}/bulk-update`,
                     params: {
@@ -131,23 +168,28 @@ export const templateListingServices = {
             catch (error) {
                 return Promise.reject(error);
             }
-        }),
-        validateName: ({ params, auth, }) => __awaiter(void 0, void 0, void 0, function* () {
+        },
+        validateName: async ({ params, auth, }) => {
             try {
-                const response = yield axios({
+                const response = await axios({
                     method: 'POST',
                     url: `${auth.url}/${OBJECT_TEMPLATE_ROUTE}/validate-name`,
-                    params: Object.assign({ _token: auth.token, _user_id: auth.userId, _account_id: auth.accountId }, params),
+                    params: {
+                        _token: auth.token,
+                        _user_id: auth.userId,
+                        _account_id: auth.accountId,
+                        ...params,
+                    },
                 });
                 return get(response, 'data.data', {});
             }
             catch (error) {
                 return Promise.reject(error);
             }
-        }),
-        getSaveAsGalleryPermission: ({ auth, }) => __awaiter(void 0, void 0, void 0, function* () {
+        },
+        getSaveAsGalleryPermission: async ({ auth, }) => {
             try {
-                const response = yield axios({
+                const response = await axios({
                     method: 'GET',
                     url: `${auth.url}/${OBJECT_TEMPLATE_ROUTE}/save-as-gallery-permission-emails`,
                 });
@@ -156,6 +198,6 @@ export const templateListingServices = {
             catch (error) {
                 return Promise.reject(error);
             }
-        }),
+        },
     },
 };

package/es/services/ThirParty/ListFallbackBO/getListFallbackBO.d.ts

@@ -0,0 +1,2 @@
+import type { TServiceAuth } from '@antscorp/antsomi-ui/es/types';
+export declare const getListFallbackBO: (serviceAuth: TServiceAuth) => Promise<any[] | null>;

package/es/services/ThirParty/ListFallbackBO/getListFallbackBO.js

@@ -0,0 +1,20 @@
+// Libraries
+import get from 'lodash/get';
+import omit from 'lodash/omit';
+// Services
+import { services } from '@antscorp/antsomi-ui/es/services';
+// Constants
+import { FallbackBO } from '@antscorp/antsomi-ui/es/models/FallbackBO';
+export const getListFallbackBO = async (serviceAuth) => {
+    try {
+        const response = await services.mediaTemplateDesign.getList({
+            API_HOST: `${serviceAuth.url}/third-party/list-fallback-bo`,
+        }, omit(serviceAuth, 'url'));
+        const listFallbackBO = get(response, 'data.data', []);
+        return listFallbackBO.map((fallbackBo) => new FallbackBO(fallbackBo));
+    }
+    catch (error) {
+        // eslint-disable-next-line no-promise-executor-return
+        return new Promise((_, reject) => reject(error));
+    }
+};

package/es/services/ThirParty/TableBO/index.d.ts

@@ -0,0 +1,6 @@
+import type { TServiceAuth } from '@antscorp/antsomi-ui/es/types';
+export interface TDataTableBO {
+    header: any[];
+    data: any[];
+}
+export declare const getDataTableBO: (serviceAuth: TServiceAuth, id: string | number) => Promise<TDataTableBO>;

package/es/services/ThirParty/TableBO/index.js

@@ -0,0 +1,19 @@
+// Libraries
+import get from 'lodash/get';
+import omit from 'lodash/omit';
+// Services
+import { services } from '@antscorp/antsomi-ui/es/services';
+export const getDataTableBO = async (serviceAuth, id) => {
+    try {
+        const response = await services.mediaTemplateDesign.get({
+            API_HOST: `${serviceAuth.url}/third-party/data-table-bo`,
+            id,
+        }, omit(serviceAuth, 'url'));
+        return get(response, 'data.data', null);
+    }
+    catch (error) {
+        return new Promise((_, reject) => {
+            reject(error);
+        });
+    }
+};

package/es/services/ThirParty/index.js

@@ -1,12 +1,3 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 /* eslint-disable no-promise-executor-return */
 // Libraries
 import get from 'lodash/get';
@@ -14,13 +5,16 @@ import get from 'lodash/get';
 import { services } from '..';
 // Models
 import { EventTrackingAttribute } from '../../models/EventTrackingAttribute';
-export const getEventTrackingAttributes = (payload, infos) => __awaiter(void 0, void 0, void 0, function* () {
+export const getEventTrackingAttributes = async (payload, infos) => {
     try {
-        const response = yield services.mediaTemplateDesign.getList(Object.assign({ API_HOST: `${payload.url}/third-party/event-tracking-attributes` }, payload), infos);
+        const response = await services.mediaTemplateDesign.getList({
+            API_HOST: `${payload.url}/third-party/event-tracking-attributes`,
+            ...payload,
+        }, infos);
         const eventTrackingAttributeData = new EventTrackingAttribute(get(response, 'data.data', {}));
         return eventTrackingAttributeData;
     }
     catch (error) {
         return new Promise((_, reject) => reject(error));
     }
-});
+};

package/es/services/Ticket.js

@@ -10,59 +10,59 @@ const API = {
         },
     },
     getAppInfo: {
-        getAll: (params, domain, config, token, userId) => callApiWithAuth(`api/privilege/index`, 'GET', Object.assign({}, params), domain, config, token, userId, true, 'list-app', false, false).then(res => {
+        getAll: (params, domain, config, token, userId) => callApiWithAuth(`api/privilege/index`, 'GET', { ...params }, domain, config, token, userId, true, 'list-app', false, false).then(res => {
             const data = getData(res, []);
             return data;
         }),
     },
     tickets: {
         callApi: {
-            createTicket: (params, domain, token, config, userId) => callApiWithAuth(`api/ticket/index`, 'POST', Object.assign({}, params), domain, config, token, userId, true).then(res => {
+            createTicket: (params, domain, token, config, userId) => callApiWithAuth(`api/ticket/index`, 'POST', { ...params }, domain, config, token, userId, true).then(res => {
                 const data = getEntriesV2(res, 0);
                 // dataBackup[params.objectName] = data;
                 return data;
             }),
-            getCustomFields: (params, domain, token, config, userId, type) => callApiWithAuth(`api/ticket/index`, 'get', Object.assign({}, params), domain, config, token, userId, true, type).then(res => 
+            getCustomFields: (params, domain, token, config, userId, type) => callApiWithAuth(`api/ticket/index`, 'get', { ...params }, domain, config, token, userId, true, type).then(res => 
             // const data = getEntriesV2(res, 0);
             // dataBackup[params.objectName] = data;
-            res === null || res === void 0 ? void 0 : res.data),
-            getDetailsTicket: (params, domain, token, config, userId, ticketId, type) => callApiWithAuth(`api/ticket/index/${ticketId}`, 'get', Object.assign({}, params), domain, config, token, userId, true, type).then(res => 
+            res?.data),
+            getDetailsTicket: (params, domain, token, config, userId, ticketId, type) => callApiWithAuth(`api/ticket/index/${ticketId}`, 'get', { ...params }, domain, config, token, userId, true, type).then(res => 
             // const data = getEntriesV2(res, 0);
             // dataBackup[params.objectName] = data;
-            res === null || res === void 0 ? void 0 : res.data),
-            getListComment: (params, domain, token, config, userId, type, ticketId) => callApiWithAuth(`api/ticket/index/${ticketId}`, 'get', Object.assign({}, params), domain, config, token, userId, true, type).then(res => 
+            res?.data),
+            getListComment: (params, domain, token, config, userId, type, ticketId) => callApiWithAuth(`api/ticket/index/${ticketId}`, 'get', { ...params }, domain, config, token, userId, true, type).then(res => 
             // const data = getEntriesV2(res, 0);
             // dataBackup[params.objectName] = data;
-            res === null || res === void 0 ? void 0 : res.data),
-            updateComment: (params, domain, token, config, userId, type, ticketId) => callApiWithAuth(`api/ticket/index/${ticketId}`, 'put', Object.assign({}, params), domain, config, token, userId, true, type).then(res => 
+            res?.data),
+            updateComment: (params, domain, token, config, userId, type, ticketId) => callApiWithAuth(`api/ticket/index/${ticketId}`, 'put', { ...params }, domain, config, token, userId, true, type).then(res => 
             // const data = getEntriesV2(res, 0);
             // dataBackup[params.objectName] = data;
-            res === null || res === void 0 ? void 0 : res.data),
-            updateFollowers: (params, domain, token, config, userId, ticketId) => callApiWithAuth(`api/ticket/index/${ticketId}`, 'put', Object.assign({}, params), domain, config, token, userId, true).then(res => 
+            res?.data),
+            updateFollowers: (params, domain, token, config, userId, ticketId) => callApiWithAuth(`api/ticket/index/${ticketId}`, 'put', { ...params }, domain, config, token, userId, true).then(res => 
             // const data = getEntriesV2(res, 0);
             // dataBackup[params.objectName] = data;
-            res === null || res === void 0 ? void 0 : res.data),
+            res?.data),
             upload: (params, domain, token, config, userId, type) => callApiWithAuth(`api/upload/index`, 'post', params.data, domain, config, token, userId, true, type).then(res => 
             // const data = getEntriesV2(res, 0);
             // dataBackup[params.objectName] = data;
-            res === null || res === void 0 ? void 0 : res.data),
+            res?.data),
         },
     },
     accounts: {
         callApi: {
-            getAccountManage: (params, domain, token, config, userId, type) => callApiWithAuth(`api/network/index/${config.api_pid}`, 'GET', Object.assign({}, params), domain, config, token, userId, false, type, true).then(res => res === null || res === void 0 ? void 0 : res.data),
+            getAccountManage: (params, domain, token, config, userId, type) => callApiWithAuth(`api/network/index/${config.api_pid}`, 'GET', { ...params }, domain, config, token, userId, false, type, true).then(res => res?.data),
         },
     },
     permission: {
         callApi: {
             getList: (params, domain, token, config, userId, type, ownerId) => 
             // console.log({params, domain, token, config,userId, type})
-            callApiWithAuth(`api/privilege/index`, 'GET', Object.assign(Object.assign({}, params), { ownerId }), domain, config, token, userId, false, type, false, true).then(res => res === null || res === void 0 ? void 0 : res.data),
+            callApiWithAuth(`api/privilege/index`, 'GET', { ...params, ownerId }, domain, config, token, userId, false, type, false, true).then(res => res?.data),
         },
     },
     help: {
         callApi: {
-            getList: (params, domain, token, config, userId) => callApiWithAuth(`api/app/index?appCode=${params.appCode}&type=getListHelpApps&role=1`, 'GET', Object.assign({}, params), domain, config, token, userId, true).then(res => 
+            getList: (params, domain, token, config, userId) => callApiWithAuth(`api/app/index?appCode=${params.appCode}&type=getListHelpApps&role=1`, 'GET', { ...params }, domain, config, token, userId, true).then(res => 
             // console.log(res);
             // const data = res;
             // dataBackup[params.objectName] = data;

package/es/services/User/getUserInfo.d.ts

@@ -0,0 +1,8 @@
+type GetUserInfoParams = Partial<{
+    portalId: number;
+    languageCode: string;
+    token: string;
+    env: string;
+}>;
+export declare const getUserInfo: (params: GetUserInfoParams) => Promise<any>;
+export {};

package/es/services/User/getUserInfo.js

@@ -0,0 +1,22 @@
+import axios from 'axios';
+import { CDP_API } from '../../constants';
+import { ENV } from '../../config';
+export const getUserInfo = async (params) => {
+    const { env = ENV.PROD, portalId, token, languageCode = 'en' } = params;
+    try {
+        const url = `${CDP_API[env]}/hub/login-verify/user-info`;
+        const { data } = await axios.get(url, {
+            params: {
+                portalId,
+                languageCode,
+            },
+            headers: {
+                Token: token,
+            },
+        });
+        return data;
+    }
+    catch (error) {
+        return Promise.reject(error);
+    }
+};

package/es/services/User/index.d.ts

@@ -0,0 +1,9 @@
+import { TServiceAuth } from '../../types';
+import { LoggedUser } from '../../models/LoggedUser';
+export { getUserInfo } from './getUserInfo';
+export type TGetLoggedUserArgs = {
+    auth?: TServiceAuth;
+};
+export declare const userServices: {
+    getLoggedUser: (args: TGetLoggedUserArgs) => Promise<LoggedUser>;
+};

package/es/services/User/index.js

@@ -0,0 +1,27 @@
+// Libraries
+import { get } from 'lodash';
+import axios from 'axios';
+// Constants
+import { IAM_API } from '../../constants';
+export { getUserInfo } from './getUserInfo';
+export const userServices = {
+    getLoggedUser: async (args) => {
+        try {
+            const { auth } = args || {};
+            const { userId, portalId } = auth || {};
+            const response = await axios({
+                method: 'GET',
+                url: `${IAM_API}/api/3rd/info`,
+                params: {
+                    type: 'user-info',
+                    userId,
+                    networkId: portalId,
+                },
+            });
+            return get(response, 'data.data', {});
+        }
+        catch (error) {
+            return Promise.reject(error);
+        }
+    },
+};

package/es/services/index.d.ts

@@ -9,6 +9,7 @@ type UpdateParams = {
 };
 export declare const services: {
     mediaTemplateDesign: {
+        get: (params: any, payloadInfo: PayloadInfo) => false | Promise<AxiosResponse<any, any>>;
         getList: (params: any, infos: PayloadInfo) => any;
         create: (params: any, infos: PayloadInfo) => Promise<AxiosResponse<any, any> | any>;
         update: (params: UpdateParams, infos: PayloadInfo) => Promise<AxiosResponse<any, any> | any>;

package/es/services/index.js

@@ -1,15 +1,3 @@
-var __rest = (this && this.__rest) || function (s, e) {
-    var t = {};
-    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
-        t[p] = s[p];
-    if (s != null && typeof Object.getOwnPropertySymbols === "function")
-        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
-            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
-                t[p[i]] = s[p[i]];
-        }
-    return t;
-};
-var _a;
 /* eslint-disable @typescript-eslint/no-unused-expressions */
 // Libraries
 import axios from 'axios';
@@ -20,9 +8,37 @@ import qs from 'qs';
 import { searchParamsToObject } from '../utils';
 export const instance = axios.create();
 const { CancelToken } = axios;
-const isDebugApi = searchParamsToObject((((_a = window.location) === null || _a === void 0 ? void 0 : _a.href) || '').split('?')[1])['debug-api'] != null;
+const isDebugApi = searchParamsToObject((window.location?.href || '').split('?')[1])['debug-api'] != null;
 export const services = {
     mediaTemplateDesign: {
+        get: function get(params, payloadInfo) {
+            if (typeof params.API_HOST !== 'undefined' && typeof params.id !== 'undefined') {
+                const { API_HOST } = params;
+                const { userId, accountId, token } = payloadInfo;
+                const cancelToken = params.cancelToken ? params.cancelToken : new CancelToken(() => { });
+                const { signal } = params;
+                delete params.API_HOST;
+                delete params.cancelToken;
+                delete params.signal;
+                if (has(params, 'url')) {
+                    delete params.url;
+                }
+                const snapParams = {
+                    ...params,
+                    _token: token,
+                    _user_id: userId,
+                    _account_id: accountId,
+                };
+                return instance.get(API_HOST + '/' + params.id, {
+                    params: snapParams,
+                    cancelToken: cancelToken,
+                    signal,
+                });
+            }
+            else {
+                return false;
+            }
+        },
         getList: function getList(params, infos) {
             if (typeof params.API_HOST !== 'undefined') {
                 const { API_HOST } = params;
@@ -35,7 +51,12 @@ export const services = {
                 if (has(params, 'url')) {
                     delete params.url;
                 }
-                const snapParams = Object.assign(Object.assign({}, params), { _token: token, _user_id: userId, _account_id: accountId });
+                const snapParams = {
+                    ...params,
+                    _token: token,
+                    _user_id: userId,
+                    _account_id: accountId,
+                };
                 return instance.get(API_HOST, {
                     params: snapParams,
                     cancelToken,
@@ -65,7 +86,7 @@ export const services = {
             return Promise.resolve(false);
         },
         update: function update(params, infos) {
-            const { id, API_HOST, config = {}, isGzip } = params, restOfParams = __rest(params, ["id", "API_HOST", "config", "isGzip"]);
+            const { id, API_HOST, config = {}, isGzip, ...restOfParams } = params;
             const { userId, accountId, token } = infos;
             const data = isGzip && !isDebugApi ? pako.gzip(JSON.stringify(restOfParams)) : restOfParams;
             if (typeof API_HOST !== 'undefined' && typeof id !== 'undefined') {
@@ -74,10 +95,18 @@ export const services = {
                     _user_id: userId,
                     _account_id: accountId,
                 };
-                return instance.put(`${API_HOST}/${id}`, data, Object.assign(Object.assign(Object.assign({}, config), (isGzip &&
-                    !isDebugApi && {
-                    headers: Object.assign(Object.assign({}, config.headers), { 'Content-Type': 'application/json', 'content-encoding': 'gzip' }),
-                })), { params: paramsInfo }));
+                return instance.put(`${API_HOST}/${id}`, data, {
+                    ...config,
+                    ...(isGzip &&
+                        !isDebugApi && {
+                        headers: {
+                            ...config.headers,
+                            'Content-Type': 'application/json',
+                            'content-encoding': 'gzip',
+                        },
+                    }),
+                    params: paramsInfo,
+                });
             }
             return Promise.resolve(false);
         },