@nixweb/nixloc-ui 0.0.124 → 0.0.127

package/src/store/modules/report.js

@@ -3,92 +3,81 @@ import ConvertToOdata from "@nixweb/nixloc-ui/src/component/shared/query-builder
 export default {
     namespaced: true,
     state: {
-        report: {
-            fields: [],
-            rules: [],
+        report: { id: "", fields: [], rules: [], },
+        selectedFields: {},
+        selectedRules: [],
+        finalQueryFormatOData: {
+            fields: [], totalization: [],
         },
-        query_builder: { rules: [] },
-        optionTable: {
-            initialValue: [],
-            options: []
-        },
-        optionsInitValue: [],
-        queryOData: {
-            fields: [],
-            totalization: [],
-        },
-        selectedField: [],
-        campoOrdenado: {},
-        query: [],
-        totalization: [],
         tags: []
     },
     getters: {
         headerTable: (state) => {
             let list = [];
             state.report.fields.forEach(function (field) {
-                if (field.show) list.push(field);
+                if (field.selected) list.push(field);
             });
             return list;
         },
-        optionTable: (state) => {
-            // optionsInitValue é quando vem da query salva pelo usuário
-            state.optionTable = {
-                initialValue: [],
-                options: []
-            };
-
-            var hasInitValue = state.optionsInitValue.length;
+        fields: (state) => {
+            // esse getter serve somente para carregar informações no component Fields     
+            var fields = { selected: [], options: [], sort: { content: "", id: "asc" }, orderBy: "" };
 
-            state.report.fields.forEach(function (field) {
-                let option = { text: field.title, value: field.value };
-                state.optionTable.options.push(option);
+            state.report.fields.forEach(function (value) {
+                let option = { text: value.title, value: value.field };
+                fields.options.push(option);
 
-                if (field.show && hasInitValue == 0)
-                    state.optionTable.initialValue.push(option);
+                // se o relatório for o padrão, carrega as info default
+                if (state.report.id == undefined) {
+                    if (value.selected)
+                        fields.selected.push(value.field);
 
-                if (hasInitValue > 0)
-                    state.optionTable.initialValue = state.optionsInitValue;
-            });
+                    if (value.orderBy) {
+                        fields.sort = { content: value.title, id: value.field };
+                        fields.orderBy = value.orderBy;
+                    }
+                }
+                else {
+                    fields.selected = state.selectedFields.selected;
+                    fields.sort = state.selectedFields.sort;
+                    fields.orderBy = state.selectedFields.orderBy;
+                }
 
-            return state.optionTable;
-        },
-        requiredRules: (state) => {
-            var filter = state.report.rules.filter(item => item.isRequired == true);
-            return filter;
-        },
-        regraObrigatoriaJaAdicionada: (state) => (rule) => {
-            return false;
-        },
-        selectedRules: (state) => {
-            let rules = [];
-            state.report.rules.forEach(function (rule) {
-                if (rule.value != null && rule.value != "" && rule.value != undefined)
-                    rules.push(rule);
             });
-            return rules;
-        },
-        hasSelectedField: (state) => (field, value) => {
-            var hasField = value.find((item) => {
-                if (field == value) return true;
-            });
-            return hasField;
+            return fields;
         },
         oDataOrderBy: (state) => {
-            let orderBy = `$orderby=${state.campoOrdenado.id} ${state.campoOrdenado.ordenar}`;
-            return "";
+            let orderBy = "";
+            if (state.selectedFields.sort != undefined)
+                orderBy = `$orderby=${state.selectedFields.sort.id} ${state.selectedFields.orderBy}`;
+            return orderBy;
         },
         oDataSelect: (state) => {
+            let selectedFields = [];
+
+            // verifica os campos obrigatórios por default "requiredOData" 
+            state.report.fields.forEach(value => {
+                if (value.requiredOData)
+                    selectedFields.push(value.field);
+            });
+
+            // verifica os campos selecionados pelo usuário
+            if (state.selectedFields.selected != undefined) {
+                state.selectedFields.selected.forEach(function (field) {
+                    selectedFields.push(field);
+                });
+            }
+
             let query = "";
             let indexQuery = 0;
 
-            state.queryOData.fields.forEach(function (rule) {
-                if (rule.show || rule.isRequired) {
-                    if (indexQuery == 0) query += `$select=${rule.formatOdata}`;
-                    if (indexQuery > 0) query += `,${rule.formatOdata}`;
-                    indexQuery++;
-                }
+            // remove itens duplicados e monta a query select
+            [...new Set(selectedFields)].forEach(field => {
+                if (indexQuery == 0) query += `$select=${field}`;
+                if (indexQuery > 0) query += `,${field}`;
+                indexQuery++;
             });
+
             return query;
         },
         oDataFilter: (state) => {
@@ -96,10 +85,10 @@ export default {
             let totalization = "";
             let indexQuery = 0;
             let indexTotalization = 0;
-            var size = state.queryOData.fields.length;
+            var size = state.finalQueryFormatOData.fields.length;
             var andOr = [];
 
-            state.queryOData.fields.forEach(function (rule) {
+            state.finalQueryFormatOData.fields.forEach(function (rule) {
                 if (rule.type == "field") {
                     if (indexQuery == 0 && size > 0) query += `$filter=${rule.formatOdata}`;
 
@@ -109,8 +98,8 @@ export default {
                     }
                     indexQuery++;
 
-                    /* Verifica no array se o último item é o "and", se sim será necessário inserir "(" depois do filter = e ")" antes do "and" 
-                       para que o oData consiga efetuar a query corretamente */
+                    // verifica no array se o último item é o "and", se sim será necessário inserir "(" depois do filter = e ")" antes do "and" 
+                    //  para que o oData consiga efetuar a query corretamente
                     if (andOr[andOr.length - 1] == "and") {
 
                         let initIndex = query.indexOf("=");
@@ -130,24 +119,25 @@ export default {
             return { query, totalization };
         },
         tags: (state) => {
-
             state.tags = [];
             let description = "";
 
-            state.queryOData.fields.forEach(function (rule) {
-                if (rule.fieldType == "dateTime") {
+            state.finalQueryFormatOData.fields.forEach(function (rule) {
+                description = "";
+
+                if (rule.typeField == "dateTime") {
                     description = `${rule.value[0]} - ${rule.value[1]}`;
                 }
 
-                if (rule.fieldType == "select") {
+                if (rule.typeField == "select") {
                     description = rule.value.content;
                 }
 
-                if (rule.fieldType == "text" || rule.fieldType == "numeric") {
+                if (rule.typeField == "text" || rule.typeField == "numeric") {
                     description = `${rule.operator} "${rule.value}"`;
                 }
 
-                if (rule.fieldType == "checkbox") {
+                if (rule.typeField == "checkbox") {
                     rule.options.forEach(function (option) {
                         rule.value.forEach(function (value) {
                             if (option.value == value) {
@@ -159,52 +149,57 @@ export default {
 
                 let tag = { id: rule.id, title: rule.title, value: description };
                 state.tags.push(tag);
+
             });
             return state.tags;
-        }
+
+        },
+        rulesIsValid: (state) => {
+            let isValid = false;
+            let rulesRequired = state.report.rules.filter(x => x.isRequired);
+            let rulesRequiredSelected = state.selectedRules.filter(x => x.isRequired);
+
+            if (rulesRequired.length == rulesRequiredSelected.length)
+                isValid = true;
+
+            return isValid;
+        },
+        rulesRequired: (state) => {
+            return state.report.rules.filter(x => x.isRequired);
+        },
     },
     mutations: {
-        addFieldsReport: (state, fields) => {
-            state.report.fields = fields;
-        },
-        addRulesReport: (state, rules) => {
-            state.report.rules = rules;
+        updateSelectedFields: (state, selectedFields) => {
+            state.selectedFields = selectedFields;
+            // após selecionar o campo, atualiza tambem quais campos deverão aparecer no report
+            // se foi selecionado é marcado como selected = true
+            state.report.fields.forEach(function (value) {
+                var hasSelected = selectedFields.selected.find((selected) => {
+                    if (value.field == selected) return true;
+                });
+                if (value.field === hasSelected) {
+                    value.selected = true;
+                } else {
+                    value.selected = false;
+                }
+            });
         },
         addSelectedRules: (state, selectedRule) => {
-            state.query_builder.rules.push(selectedRule);
+            state.selectedRules.push(selectedRule);
         },
         removeSelectedRule: (state, id) => {
-            var filter = state.query_builder.rules.filter((item) => {
+            var filter = state.selectedRules.filter((item) => {
                 return id != item.id;
             })
-            state.query_builder.rules = filter;
-        },
-        updateSelectedField: (state, value) => {
-            state.selectedField = value;
+            state.selectedRules = filter;
         },
-        updateOptionsInitValue: (state, value) => {
-            state.optionsInitValue = value;
-        },
-        atualizaFiltroSelecionado: (state, value) => {
-            state.filtroSelecionado = value;
-        },
-        atualizaCampoOrdenado: (state, value) => {
-            state.campoOrdenado = value;
-        },
-        removeFiltroSelecionado: (state, id) => {
-            var filter = state.filtroSelecionado.children.filter((x) => {
-                return x.query.id != id;
-            });
-            state.filtroSelecionado.children = filter;
-        },
-        convertRulesToOdata: (state, rules) => {
-            state.queryOData = {
-                fields: [],
-                totalization: [],
-            };
+        mountFinalQueryFormatOData: (state, selectedRules) => {
+            // aqui faz a conversão das regras selecionadas no padrão do query-builder para o formato oData carregando no objeto finalQueryFormatOData
+            // para ser consumido nos getters oDataSelect e oDataFilter
 
-            rules.forEach(function (rule) {
+            state.finalQueryFormatOData = { fields: [], totalization: [] };
 
+            selectedRules.forEach(function (rule) {
                 /*  if (key.query.choices && key.query.type == "totalization") {
                       key.query.choices.forEach(function (value) {
                           let obj = {
@@ -220,27 +215,43 @@ export default {
 
                 if (rule.value != null && rule.value != "" && rule.value != undefined) {
 
-                    let convertToOdata = new convertToOdata();
-                    let formatOdata = convertToOdata.ConvertToOdata(rule);
+                    let convertToOdata = new ConvertToOdata();
+                    let formatOdata = convertToOdata.convertRule(rule);
 
                     let ruleOdata = {
                         id: rule.id,
                         title: rule.title,
                         type: rule.type,
-                        fieldType: rule.fieldType,
+                        typeField: rule.typeField,
                         options: rule.options,
                         operator: rule.operator,
-                        show: rule.show,
+                        selected: rule.selected,
                         isRequired: rule.isRequired,
                         formatOdata: formatOdata,
                         andOr: rule.andOr,
                         value: rule.value,
                     };
 
-                    state.queryOData.fields.push(ruleOdata);
+                    state.finalQueryFormatOData.fields.push(ruleOdata);
                 }
             });
-        }
-
+        },
     },
+    actions: {
+        addReport: async function (context, report) {
+            context.state.report = report;
+            context.state.selectedFields = context.getters.fields;
+        },
+        addInitialReportCustom: async function (context, report) {
+            context.state.selectedFields = report.selectedFields;
+            context.state.selectedRules = report.selectedRules;
+            context.commit('mountFinalQueryFormatOData', report.selectedRules);
+            context.commit('updateSelectedFields', report.selectedFields);
+        },
+        removeInitialReportCustom: async function (context) {
+            context.state.selectedFields = {};
+            context.state.selectedRules = [];
+            context.state.finalQueryFormatOData.fields = [];
+        }
+    }
 }

package/src/store/modules/user.js

@@ -34,5 +34,8 @@ export default {
         removeItemMenu: (state) => {
             state.menu.items = [];
         },
+        updateParameterRental: (state, parameterRental) => {
+            state.userLogged.parameterRental = parameterRental;
+        }
     },
 }