@pxp-nd/flow 1.0.21 → 1.0.25

package/dist/controllers/Flow.js

@@ -35,8 +35,22 @@ let Flow = class Flow extends core_1.Controller {
         const nodes = await Node_1.default.find({ flowId: params.flowId });
         const restNodes = [];
         for (let node of nodes) {
+            const { actionConfigJson, action: { actionType: { schemaJson } } } = node;
+            const actionConfigJsonObject = actionConfigJson ? JSON.parse(actionConfigJson) : {};
+            const schemaJsonObject = schemaJson ? JSON.parse(schemaJson) : {};
+            const valuesForShowingInNode = {};
+            Object.entries(schemaJsonObject).filter(([n, sjo]) => sjo.showInNode === true).forEach(([nameKey, json]) => {
+                valuesForShowingInNode[nameKey] = {
+                    label: json.label,
+                    value: actionConfigJsonObject[nameKey] || null
+                };
+            });
+            const nodeRow = {
+                ...node,
+                valuesForShowingInNode
+            };
             const connections = await NodeConnection_1.default.find({ nodeIdMaster: node.nodeId });
-            restNodes.push({ node, connections: connections.map(c => c.nodeIdChild) });
+            restNodes.push({ node: nodeRow, connections: connections.map(c => c.nodeIdChild) });
         }
         return restNodes;
     }

package/dist/controllers/Node.js

@@ -32,6 +32,7 @@ const core_1 = require("@pxp-nd/core");
 const lodash_1 = __importDefault(require("lodash"));
 const FieldMap_1 = __importDefault(require("../entity/FieldMap"));
 const OriginName_1 = __importDefault(require("../entity/OriginName"));
+const axios_1 = __importDefault(require("axios"));
 let Node = class Node extends core_1.Controller {
     async getNodeData(node, dataId, manager) {
         const { action: { originName, originKey } } = node;
@@ -81,20 +82,21 @@ let Node = class Node extends core_1.Controller {
     }
     async getParameterizedNode(params, manager) {
         lodash_1.default.templateSettings.interpolate = /{{([\s\S]+?)}}/g;
-        const { nodeId, flowId, substitutionsSchemaJson } = params;
-        /*const tNodeOrigin =  __(NodeModel.find({
-          relations: ['action'],
-          where: {
-            flowId: flowId,
-            action: {
-              originName: Not(IsNull())
+        const { nodeId, flowId, substitutionsSchemaJson = {} } = params;
+        const tNodeOrigin = await core_1.__(Node_1.default.findOne({
+            relations: ['action'],
+            where: {
+                flowId: flowId,
+                isInit: 'Y',
+                action: {
+                    originName: typeorm_1.Not(typeorm_1.IsNull())
+                }
             }
-          }
-        }));*/
+        }));
         const tNodeData = core_1.__(Node_1.default.findOne(nodeId));
         const tFieldMapData = core_1.__(manager.createQueryBuilder(FieldMap_1.default, 'fm')
             .innerJoin(OriginName_1.default, 'on', 'on.originNameId = fm.originNameId')
-            .where("on.name = :n ", { n: 'v_member' })
+            .where("on.name = :n ", { n: tNodeOrigin.action.originName })
             .getMany());
         //const nodeOrigin = await tNodeOrigin; todo
         const nodeData = await tNodeData;
@@ -126,14 +128,81 @@ let Node = class Node extends core_1.Controller {
                 metadata: found
             };
         };
-        Object.entries(mergeValues).forEach(([nameKey, value]) => {
+        const findFieldMapUniqueByType = (fieldMappingType) => {
+            const filtered = fieldMapData.filter((fmd) => fmd.type === fieldMappingType);
+            if (filtered && filtered.length === 1) {
+                const [found] = filtered;
+                return {
+                    initialValue: found.alias,
+                    metadata: found
+                };
+            }
+            return undefined;
+        };
+        // this logic is for autocomplete for moment
+        const findFieldInConfigForComponent = async (json, value) => {
+            if (json.formComponent && json.formComponent.type === 'AutoComplete') {
+                const url = json.formComponent.store.axios.url;
+                const method = json.formComponent.store.axios.method;
+                const data = json.formComponent.store.axios.data;
+                const idDD = json.formComponent.store.idDD;
+                const descDD = json.formComponent.store.descDD;
+                const config = {
+                    method: method,
+                    url: url,
+                    headers: {
+                        'Authorization': '' + process.env.TOKEN_PXP_ND + '',
+                        'Content-Type': 'application/json'
+                    },
+                    data: {
+                        ...data,
+                        [idDD]: value
+                    }
+                };
+                // @ts-ignore
+                const resControllerAxios = await core_1.__(axios_1.default(config));
+                const desc = resControllerAxios.data.data[descDD];
+                return desc;
+            }
+            else if (json.formComponentTemplate && json.configGetDescValue) { // todo we need to see how works here
+                const { controller, storeId, descColumn } = json.configGetDescValue;
+                const config = {
+                    method: "get",
+                    url: `http://localhost:${process.env.PORT}/api/${controller}`,
+                    headers: {
+                        'Authorization': '' + process.env.TOKEN_PXP_ND + '',
+                        'Content-Type': 'application/json'
+                    },
+                    data: {
+                        [storeId]: value
+                    }
+                };
+                // @ts-ignore
+                const resControllerAxios = await core_1.__(axios_1.default(config));
+                const desc = resControllerAxios.data.data[descColumn];
+                return desc;
+            }
+            return undefined;
+        };
+        for (const [nameKey, value] of Object.entries(mergeValues)) {
             if (schemaJsonObject[nameKey]) {
+                const descValue = await core_1.__(findFieldInConfigForComponent(schemaJsonObject[nameKey], value));
                 schemaJsonObject[nameKey] = {
                     ...schemaJsonObject[nameKey],
                     initialValue: value,
+                    ...(descValue && { descValue: descValue }),
                     ...(verifyIfValueFromFieldMap(value) && { fromFieldMap: true, ...findFieldMapAndMetaData(value) }),
                 };
             }
+        }
+        Object.entries(schemaJsonObject)
+            .filter(([, value]) => value.initialValue === undefined && value.fromFieldMap === undefined && value.fieldMappingType)
+            .forEach(([nameKey]) => {
+            const hasUniqueByTypeInMappingData = findFieldMapUniqueByType(schemaJsonObject[nameKey].fieldMappingType);
+            schemaJsonObject[nameKey] = {
+                ...schemaJsonObject[nameKey],
+                ...(hasUniqueByTypeInMappingData && { fromFieldMap: true, ...hasUniqueByTypeInMappingData }),
+            };
         });
         return {
             actionConfigJsonObject,

package/dist/entity/Action.d.ts

@@ -11,6 +11,7 @@ export default class Action extends PxpEntity {
     originKey: string;
     controllerFunction: string;
     configJsonTemplate: string;
+    eventConfig: string;
     hidden: string;
     schemaJson: string;
     actionType: ActionType;

package/dist/entity/Action.js

@@ -54,6 +54,10 @@ __decorate([
     typeorm_1.Column({ name: 'config_json_template', type: 'text' }),
     __metadata("design:type", String)
 ], Action.prototype, "configJsonTemplate", void 0);
+__decorate([
+    typeorm_1.Column({ name: 'event_config', type: 'text' }),
+    __metadata("design:type", String)
+], Action.prototype, "eventConfig", void 0);
 __decorate([
     typeorm_1.Column({ type: 'varchar', nullable: false, length: 1, default: 'N' }),
     __metadata("design:type", String)

package/dist/subscribers/Event.d.ts

@@ -17,4 +17,5 @@ import EventModel from '../entity/Event';
 export declare class Event implements EntitySubscriberInterface<EventModel> {
     listenTo(): typeof EventModel;
     afterInsert(event: InsertEvent<EventModel>): Promise<void>;
+    checkConditions(viewData: Record<string, any>, flowId: number, actionId: number): Promise<boolean>;
 }

package/dist/subscribers/Event.js

@@ -27,6 +27,7 @@ exports.Event = void 0;
 const typeorm_1 = require("typeorm");
 const Event_1 = __importDefault(require("../entity/Event"));
 const Node_1 = __importDefault(require("../entity/Node"));
+const Action_1 = __importDefault(require("../entity/Action"));
 const Flow_1 = __importDefault(require("../entity/Flow"));
 const core_1 = require("@pxp-nd/core");
 const FlowInstance_1 = __importDefault(require("../entity/FlowInstance"));
@@ -45,7 +46,8 @@ let Event = class Event {
             const executeView = `select * from ${originName} where ${originKey} = ${newEvent.dataId}`;
             const resExecuteView = await typeorm_1.getManager().query(executeView);
             const flow = await core_1.__(Flow_1.default.findOne({ where: { flowId: n.flowId } }));
-            if (flow.vendorId == resExecuteView[0].vendor_id) {
+            if (flow.vendorId == resExecuteView[0].vendor_id && this.checkConditions(resExecuteView[0], n.flowId, newEvent.actionId)) {
+                //now check all conditions
                 let flowInstance = new FlowInstance_1.default();
                 flowInstance.flowId = n.flowId;
                 flowInstance.dataId = newEvent.dataId;
@@ -57,6 +59,23 @@ let Event = class Event {
             }
         }
     }
+    async checkConditions(viewData, flowId, actionId) {
+        const action = await Action_1.default.findOne(actionId);
+        const node = await Node_1.default.findOne({ where: { actionId, flowId } });
+        const actionConfigJson = JSON.parse(node.actionConfigJson);
+        let res = true;
+        if (action.eventConfig) {
+            const eventConfig = JSON.parse(action.eventConfig);
+            if (eventConfig.filters) {
+                eventConfig.filters.forEach((filter) => {
+                    if (actionConfigJson[filter.nodeField] && viewData[filter.originField] != actionConfigJson[filter.nodeField]) {
+                        res = false;
+                    }
+                });
+            }
+        }
+        return res;
+    }
 };
 Event = __decorate([
     typeorm_1.EventSubscriber()

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pxp-nd/flow",
-  "version": "1.0.21",
+  "version": "1.0.25",
   "description": "Workflow module for pxp-nd framework",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",