Dash public api actions

src/server/components/public-api/config/v0.ts

@@ -113,31 +113,31 @@ export const getPublicApiActionsV0 = <
 
         // Dashboard
         getDashboard: {
-            resolve: (api) => api.mix.__getDashboard__,
+            resolve: (api) => api.mix.getDashboardV1,
             openApi: {
                 summary: 'Get dashboard',
                 tags: [ApiTag.Dashboard],
                 experimental: true,
             },
         },
         createDashboard: {
-            resolve: (api) => api.mix.__createDashboard__,
+            resolve: (api) => api.mix.createDashboardV1,
             openApi: {
                 summary: 'Create dashboard',
                 tags: [ApiTag.Dashboard],
                 experimental: true,
             },
         },
         updateDashboard: {
-            resolve: (api) => api.mix.__updateDashboard__,
+            resolve: (api) => api.mix.updateDashboardV1,
             openApi: {
                 summary: 'Update dashboard',
                 tags: [ApiTag.Dashboard],
                 experimental: true,
             },
         },
         deleteDashboard: {
-            resolve: (api) => api.mix._deleteDashboard,
+            resolve: (api) => api.mix.deleteDashboard,
             openApi: {
                 summary: 'Delete dashboard',
                 tags: [ApiTag.Dashboard],
@@ -209,7 +209,7 @@ export const getPublicApiActionsV0 = <
             },
         },
         deleteQLChart: {
-            resolve: (api) => api.mix._deleteQLChart,
+            resolve: (api) => api.mix.deleteQLChart,
             openApi: {
                 summary: 'Delete QL chart',
                 tags: [ApiTag.QL],
@@ -226,7 +226,7 @@ export const getPublicApiActionsV0 = <
             },
         },
         deleteWizardChart: {
-            resolve: (api) => api.mix._deleteWizardChart,
+            resolve: (api) => api.mix.deleteWizardChart,
             openApi: {
                 summary: 'Delete wizard chart',
                 tags: [ApiTag.Wizard],

src/server/components/sdk/dash.ts

@@ -93,7 +93,7 @@ function processLinks(data: DashData, matchCallback?: MatchCallback) {
     );
 }
 
-function gatherLinks(data: DashData) {
+export function gatherLinks(data: DashData) {
     return processLinks(data);
 }
 
@@ -144,7 +144,7 @@ function setDefaultData(
 const needSetDefaultData = (data: DashData) =>
     DASH_DATA_REQUIRED_FIELDS.some((fieldName) => !(fieldName in data));
 
-function validateData(data: DashData) {
+export function validateData(data: DashData) {
     const allTabsIds: Set<string> = new Set();
     const allItemsIds: Set<string> = new Set();
     const allWidgetTabsIds: Set<string> = new Set();
@@ -248,7 +248,7 @@ class Dash {
                 isEnabledServerFeature(Feature.DashServerMigrationEnable),
             );
             if (isServerMigrationEnabled && DashSchemeConverter.isUpdateNeeded(usData.data)) {
-                usData.data = await DashSchemeConverter.update(usData.data);
+                usData.data = DashSchemeConverter.update(usData.data);
             }
 
             usData.links = gatherLinks(usData.data);
@@ -302,7 +302,7 @@ class Dash {
                 (options?.forceMigrate || isServerMigrationEnabled) &&
                 DashSchemeConverter.isUpdateNeeded(result.data)
             ) {
-                result.data = await Dash.migrate(result.data);
+                result.data = Dash.migrate(result.data);
             }
 
             ctx.log('SDK_DASH_READ_SUCCESS', US.getLoggedEntry(result));
@@ -315,7 +315,7 @@ class Dash {
         }
     }
 
-    static async migrate(data: DashEntry['data']) {
+    static migrate(data: DashEntry['data']) {
         return DashSchemeConverter.update(data);
     }
 

src/server/components/workbook-transfer/dash.ts

@@ -18,11 +18,11 @@ import {
     warningTransferNotification,
 } from './create-transfer-notifications';
 
-export async function prepareDashImportData(
+export function prepareDashImportData(
     entryData: {data: DashEntry['data']; name: string; annotation?: EntryAnnotation},
     idMapping: TransferIdMapping,
 ) {
-    const data = await Dash.migrate(entryData.data);
+    const data = Dash.migrate(entryData.data);
     const notifications: TransferNotification[] = [];
     const description = entryData.annotation?.description ?? '';
     const defaults = {
@@ -86,8 +86,8 @@ export async function prepareDashImportData(
     };
 }
 
-export async function prepareDashExportData(entry: DashEntry, idMapping: TransferIdMapping) {
-    const data = await Dash.migrate(entry.data);
+export function prepareDashExportData(entry: DashEntry, idMapping: TransferIdMapping) {
+    const data = Dash.migrate(entry.data);
     const notifications: TransferNotification[] = [];
     let isMissingMapping = false;
 

src/server/controllers/workbook-transfer.ts

@@ -126,7 +126,7 @@ export const prepareExportData = async (req: Request, res: Response) => {
                 ]);
             }
 
-            const {dash, notifications} = await prepareDashExportData(
+            const {dash, notifications} = prepareDashExportData(
                 Dash.migrateDescription(entry as unknown as DashEntry),
                 idMapping,
             );
@@ -270,7 +270,7 @@ export const prepareImportData = async (req: Request, res: Response) => {
             return createImportResponseData(notifications, responseData.entryId);
         }
         case EntryScope.Dash: {
-            const {dash, notifications} = await prepareDashImportData(entryData.dash, idMapping);
+            const {dash, notifications} = prepareDashImportData(entryData.dash, idMapping);
 
             if (!dash) {
                 return createImportResponseData(notifications);

src/shared/modules/dash-scheme-converter.ts

@@ -73,7 +73,7 @@ class DashSchemeConverter {
         return data;
     }
 
-    static async upTo3(data: any) {
+    static upTo3(data: any) {
         const {salt, pages, counter, schemeVersion} = data;
 
         if (schemeVersion >= 3) {
@@ -86,74 +86,63 @@ class DashSchemeConverter {
 
         const {id: pageId, tabs} = page;
 
-        const convertedTabs = await Promise.all(
-            tabs.map(async (tab: any) => {
-                const {id: tabId, items, title, layout, ignores = []} = tab;
-                return {
-                    id: tabId,
-                    items: await Promise.all(
-                        items.map(
-                            async ({
-                                id,
-                                data: itemData,
-                                tabs,
-                                type,
-                                defaults,
-                                namespace = 'default',
-                            }: any) => {
-                                const data = itemData || tabs;
-                                if (type === DashTabItemType.Control && !defaults) {
-                                    const defaultValue = data.control.defaultValue || '';
-
-                                    if (data.dataset) {
-                                        const {id: datasetId, fieldName} = data.dataset;
-
-                                        try {
-                                            const {fields} = savedResponses[datasetId];
-                                            //     || await sdk.bi.getDataSetFieldsById({dataSetId: datasetId});
-                                            savedResponses[datasetId] = {fields};
-
-                                            const field = fields.find(
-                                                ({title}: any) => title === fieldName,
-                                            );
-
-                                            if (field) {
-                                                data.dataset.fieldId = field.guid;
-                                                delete data.dataset.fieldName;
-                                                delete data.dataset.name;
-                                                defaults = {[field.guid]: defaultValue};
-                                            } else {
-                                                defaults = {[fieldName]: defaultValue};
-                                            }
-                                        } catch (error) {
-                                            console.error('DATASET_FIELDS', id, error);
-                                            defaults = {[fieldName]: defaultValue};
-                                        }
+        const convertedTabs = tabs.map((tab: any) => {
+            const {id: tabId, items, title, layout, ignores = []} = tab;
+            return {
+                id: tabId,
+                items: items.map(
+                    ({id, data: itemData, tabs, type, defaults, namespace = 'default'}: any) => {
+                        const data = itemData || tabs;
+                        if (type === DashTabItemType.Control && !defaults) {
+                            const defaultValue = data.control.defaultValue || '';
+
+                            if (data.dataset) {
+                                const {id: datasetId, fieldName} = data.dataset;
+
+                                try {
+                                    const {fields} = savedResponses[datasetId];
+
+                                    savedResponses[datasetId] = {fields};
+
+                                    const field = fields.find(
+                                        ({title}: any) => title === fieldName,
+                                    );
+
+                                    if (field) {
+                                        data.dataset.fieldId = field.guid;
+                                        delete data.dataset.fieldName;
+                                        delete data.dataset.name;
+                                        defaults = {[field.guid]: defaultValue};
                                     } else {
-                                        const connection = tab.connections.find(
-                                            ({fromId}: any) => fromId === id,
-                                        );
-
-                                        if (connection) {
-                                            data.control.fieldName = connection.param;
-                                            defaults = {[connection.param]: defaultValue};
-                                        } else {
-                                            defaults = {};
-                                        }
+                                        defaults = {[fieldName]: defaultValue};
                                     }
-                                } else if (!defaults) {
+                                } catch (error) {
+                                    console.error('DATASET_FIELDS', id, error);
+                                    defaults = {[fieldName]: defaultValue};
+                                }
+                            } else {
+                                const connection = tab.connections.find(
+                                    ({fromId}: any) => fromId === id,
+                                );
+
+                                if (connection) {
+                                    data.control.fieldName = connection.param;
+                                    defaults = {[connection.param]: defaultValue};
+                                } else {
                                     defaults = {};
                                 }
-                                return {id, data, type, defaults, namespace};
-                            },
-                        ),
-                    ),
-                    title,
-                    layout,
-                    ignores,
-                };
-            }),
-        );
+                            }
+                        } else if (!defaults) {
+                            defaults = {};
+                        }
+                        return {id, data, type, defaults, namespace};
+                    },
+                ),
+                title,
+                layout,
+                ignores,
+            };
+        });
 
         return {
             salt,
@@ -164,8 +153,8 @@ class DashSchemeConverter {
     }
 
     // adding the aliases field for each tab
-    static async upTo4(originalData: any) {
-        const data = await DashSchemeConverter.upTo3(originalData);
+    static upTo4(originalData: any) {
+        const data = DashSchemeConverter.upTo3(originalData);
 
         const {salt, pages, schemeVersion, counter} = data;
 
@@ -188,8 +177,8 @@ class DashSchemeConverter {
     }
 
     // ignors for the WIDGET-elements is translated into ignors for tabs WIDGET-elements
-    static async upTo6(originalData: any) {
-        const data = await DashSchemeConverter.upTo4(originalData);
+    static upTo6(originalData: any) {
+        const data = DashSchemeConverter.upTo4(originalData);
 
         const {salt, pages, counter, schemeVersion} = data;
 
@@ -223,8 +212,8 @@ class DashSchemeConverter {
         };
     }
 
-    static async upTo7(originalData: any): Promise<DashData> {
-        const data = await DashSchemeConverter.upTo6(originalData);
+    static upTo7(originalData: any): DashData {
+        const data = DashSchemeConverter.upTo6(originalData);
 
         const {salt, pages, counter, schemeVersion, settings = {}} = data;
 
@@ -345,8 +334,8 @@ class DashSchemeConverter {
         return result;
     }
 
-    static async upTo8(originalData: any): Promise<DashData> {
-        const data = await DashSchemeConverter.upTo7(originalData);
+    static upTo8(originalData: any): DashData {
+        const data = DashSchemeConverter.upTo7(originalData);
         const {schemeVersion} = data;
 
         if (schemeVersion >= 8) {

src/shared/schema/mix/actions/dash/create-dashboard-v1.ts

@@ -0,0 +1,55 @@
+import {getTypedApi} from '../../..';
+import {EntryScope} from '../../../..';
+import {Dash} from '../../../../../server/components/sdk';
+import {createTypedAction} from '../../../gateway-utils';
+import {
+    createDashV1ArgsSchema,
+    createDashV1ResultSchema,
+} from '../../schemas/dash/create-dashboard-v1';
+import type {CreateDashV1Result, DashV1} from '../../types';
+
+export const createDashboardV1 = createTypedAction(
+    {
+        paramsSchema: createDashV1ArgsSchema,
+        resultSchema: createDashV1ResultSchema,
+    },
+    async (api, args): Promise<CreateDashV1Result> => {
+        const typedApi = getTypedApi(api);
+
+        const links = Dash.gatherLinks(args.data);
+
+        Dash.validateData(args.data);
+
+        const createEntryResult = await typedApi.us._createEntry({
+            ...args,
+            type: '',
+            scope: EntryScope.Dash,
+            links,
+        });
+
+        return {
+            entry: {
+                version: 1 as const,
+                data: createEntryResult.data as DashV1['data'],
+                meta: createEntryResult.meta as DashV1['meta'],
+                scope: createEntryResult.scope as EntryScope.Dash,
+                type: createEntryResult.type as DashV1['type'],
+                entryId: createEntryResult.entryId,
+                key: createEntryResult.key,
+                createdAt: createEntryResult.createdAt,
+                createdBy: createEntryResult.createdBy,
+                updatedAt: createEntryResult.updatedAt,
+                updatedBy: createEntryResult.updatedBy,
+                revId: createEntryResult.revId,
+                savedId: createEntryResult.savedId,
+                publishedId: createEntryResult.publishedId,
+                tenantId: createEntryResult.tenantId,
+                hidden: createEntryResult.hidden,
+                public: createEntryResult.public,
+                workbookId: createEntryResult.workbookId,
+                annotation: createEntryResult.annotation,
+                links: createEntryResult.links,
+            },
+        };
+    },
+);