@nixweb/nixloc-ui 0.0.273 → 0.0.274

package/src/store/modules/report.js

@@ -0,0 +1,278 @@
+import ConvertToOdata from "@nixweb/nixloc-ui/src/component/shared/query-builder/ConvertToOdata.js";
+
+export default {
+    namespaced: true,
+    state: {
+        report: { id: "", fields: [], rules: [], },
+        selectedFields: {},
+        selectedRules: [],
+        finalQueryFormatOData: {
+            fields: [], totalization: [],
+        },
+        tags: []
+    },
+    getters: {
+        headerTable: (state) => {
+            let list = [];
+            state.report.fields.forEach(function (field) {
+                if (field.selected) list.push(field);
+            });
+            return list;
+        },
+        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 (value) {
+                let option = { text: value.title, value: value.field };
+                fields.options.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 (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 fields;
+        },
+        oDataOrderBy: (state) => {
+            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;
+
+            // 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) => {
+            let query = "";
+            let totalization = "";
+            let indexQuery = 0;
+            let indexTotalization = 0;
+            var sizeFields = state.finalQueryFormatOData.fields.length;
+            var sizeTotalization = state.finalQueryFormatOData.totalization.length;
+            var andOr = [];
+
+
+            state.finalQueryFormatOData.fields.forEach(function (rule) {
+
+                if (rule.type == "field") {
+                    if (indexQuery == 0 && sizeFields > 0) query += `$filter=${rule.formatOdata}`;
+
+                    if (indexQuery > 0 && sizeFields > 0) {
+                        query += ` ${rule.andOr} ${rule.formatOdata}`;
+                        andOr.push(rule.andOr);
+                    }
+                    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
+                    if (andOr[andOr.length - 1] == "and") {
+
+                        let initIndex = query.indexOf("=");
+                        let lastIndex = query.indexOf("and");
+
+                        var query1 = [query.slice(0, initIndex + 1), "(", query.slice(initIndex)].join('').replace("=(=", "=(");
+                        var query2 = [query1.slice(0, lastIndex + 1), ")", query1.slice(lastIndex)].join('');
+                        query = query2;
+                    }
+
+                } else {
+                    if (indexTotalization == 0 && size > 0) totalization += `${rule.formatOdata}`;
+                    if (indexTotalization > 0 && size > 0) totalization += `,${rule.formatOdata}`;
+                    indexTotalization++;
+                }
+            });
+
+            state.finalQueryFormatOData.totalization.forEach(function (rule) {
+
+                if (indexTotalization == 0 && sizeTotalization > 0) totalization = `${rule.formatOdata}`;
+                if (indexTotalization > 0 && sizeTotalization > 0) totalization = `,${rule.formatOdata}`;
+                indexTotalization++;
+            });
+
+            return { query, totalization };
+        },
+        tags: (state) => {
+            state.tags = [];
+            let description = "";
+
+            state.finalQueryFormatOData.fields.forEach(function (rule) {
+                description = "";
+
+                if (rule.typeField == "dateTime") {
+                    description = `${rule.value[0]} - ${rule.value[1]}`;
+                }
+
+                if (rule.typeField == "select") {
+                    description = rule.value.content;
+                }
+
+                if (rule.typeField == "text" || rule.typeField == "numeric") {
+                    description = `${rule.operator} "${rule.value}"`;
+                }
+
+                if (rule.typeField == "checkbox") {
+                    rule.options.forEach(function (option) {
+                        rule.value.forEach(function (value) {
+                            if (option.value == value) {
+                                description += `${option.title},`;
+                            }
+                        });
+                    });
+                }
+
+                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: {
+        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.selectedRules.push(selectedRule);
+        },
+        removeSelectedRule: (state, id) => {
+            var filter = state.selectedRules.filter((item) => {
+                return id != item.id;
+            })
+            state.selectedRules = filter;
+        },
+        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
+
+            state.finalQueryFormatOData = { fields: [], totalization: [] };
+            var convertToOdata = new ConvertToOdata();
+
+            selectedRules.forEach(function (rule) {
+
+                if (rule.value != null && rule.value != "" && rule.value != undefined && rule.type == "totalization") {
+                    let formatOdata = convertToOdata.convertRule(rule);
+
+                    rule.value.forEach(value => {
+                        // adiciona no array somente a opção da regra selecionada
+                        var ruleSelected = rule.options.filter(x => x.value == value);
+
+                        let ruleOdata = {
+                            title: ruleSelected[0].aggregate.title,
+                            value: ruleSelected[0].aggregate.value,
+                            classCss: ruleSelected[0].aggregate.classCss,
+                            type: ruleSelected[0].aggregate.type,
+                            formatOdata: formatOdata,
+                        };
+
+                        state.finalQueryFormatOData.totalization.push(ruleOdata);
+                    });
+                }
+
+                if (rule.value != null && rule.value != "" && rule.value != undefined && rule.type == "field") {
+
+                    let formatOdata = convertToOdata.convertRule(rule);
+
+                    let ruleOdata = {
+                        id: rule.id,
+                        title: rule.title,
+                        type: rule.type,
+                        typeField: rule.typeField,
+                        options: rule.options,
+                        operator: rule.operator,
+                        selected: rule.selected,
+                        isRequired: rule.isRequired,
+                        formatOdata: formatOdata,
+                        andOr: rule.andOr,
+                        value: rule.value,
+                    };
+
+                    state.finalQueryFormatOData.fields.push(ruleOdata);
+                }
+            });
+        },
+        clearTotalization: (state) => {
+            state.finalQueryFormatOData.totalization = [];
+        }
+    },
+    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

@@ -0,0 +1,67 @@
+export default {
+    namespaced: true,
+    state: {
+        userLogged: {
+        },
+        menu: {
+            items: []
+        },
+    },
+    getters: {
+        hasRule: (state) => (name) => {
+            var hasRule = state.userLogged.user.rules.find(obj => {
+                return obj.name === name
+            })
+            if (hasRule == undefined) return false;
+            return true;
+        },
+        hasPermission: (state) => (name) => {
+            var hasRule = state.userLogged.user.rules.find(obj => {
+                return obj.name === name
+            })
+            if (hasRule == undefined) return undefined;
+            return hasRule.permission;
+        },
+        hasModule: (state) => (name) => {
+            var hasRule = state.userLogged.user.modules.find(obj => {
+                return obj.name === name
+            })
+            if (hasRule == undefined) return false;
+            return true;
+        },
+
+    },
+    mutations: {
+        addUserLogged: (state, obj) => {
+            state.userLogged = obj;
+        },
+        addItemMenu: (state, items) => {
+            items.forEach(function (obj) {
+                state.menu.items.push(obj);
+            });
+        },
+        removeItemMenu: (state) => {
+            state.menu.items = [];
+        },
+        updateParameterRental: (state, parameterRental) => {
+            state.userLogged.parameterRental = parameterRental;
+        },
+        updateParameterStock: (state, parameterStock) => {
+            state.userLogged.parameterStock = parameterStock;
+        },
+        updateParameterDangerZone: (state, parameterDangerZone) => {
+            state.userLogged.parameterStock.calculateByFullPeriod = parameterDangerZone.calculateByFullPeriod;
+            state.userLogged.parameterStock.displayPeriod = parameterDangerZone.displayPeriod;
+            state.userLogged.parameterStock.manageByPatrimony = parameterDangerZone.manageByPatrimony;
+        },
+        updateToken: (state, token) => {
+            state.userLogged.token = token;
+        },
+        updateComunication: (state) => {
+            state.userLogged.user.showComunication = false;
+        },
+        updatePhoto: (state, photo) => {
+            state.userLogged.user.photo = photo;
+        }
+    },
+}

package/src/store/modules/util.js

@@ -0,0 +1,26 @@
+export default {
+    namespaced: true,
+    getters: {
+        formatMoney: (state) => (amount) => {
+
+            var decimalCount = 2;
+            var decimal = ",";
+            var thousands = ".";
+
+            decimalCount = Math.abs(decimalCount);
+            decimalCount = isNaN(decimalCount) ? 2 : decimalCount;
+
+            const negativeSign = amount < 0 ? "-" : "";
+
+            let i = parseInt((amount = Math.abs(Number(amount) || 0).toFixed(decimalCount))).toString();
+            let j = i.length > 3 ? i.length % 3 : 0;
+
+            var ret = negativeSign + (j ? i.substring(0, j) + thousands : "") +
+                i.substring(j).replace(/(\d{3})(?=\d)/g, "$1" + thousands) +
+                (decimalCount ? decimal + Math.abs(amount - i).toFixed(decimalCount).slice(2) : "");
+
+            return ret;
+
+        },
+    },
+}

package/src/store/modules/validation.js

@@ -0,0 +1,39 @@
+export default {
+    namespaced: true,
+    state: {
+        formDirty: false,
+        validations: [],
+        resetForm: {
+            name: undefined,
+            dateTime: undefined
+        }
+    },
+    getters: {
+        isFormValid: (state) => (formName) => {
+            var hasNotification = state.validations.find(obj => {
+                return obj.formName === formName
+            })
+            if (hasNotification != undefined) return false;
+            return true;
+        }
+    },
+    mutations: {
+        addValidation: (state, obj) => {
+            state.validations.push(obj);
+        },
+        removeValidation: (state, obj) => {
+            let filter = state.validations.filter(v => v.key != obj.key);
+            state.validations = filter;
+        },
+        resetValidation: (state, formName) => {
+            state.resetForm.dateTime = new Date();
+            state.resetForm.name = formName;
+        },
+        updateFormDirty: (state, formDirty) => {
+            state.formDirty = formDirty;
+        },
+        removeFormDirty: (state) => {
+            state.formDirty = false;
+        }
+    },
+}

package/src/store/store.js

@@ -1,23 +1,14 @@
-import Vue from 'vue';
-import Vuex from 'vuex';
-import createPersistedState from "vuex-persistedstate";
-
-import generic from '@nixweb/nixloc-ui/src/store/modules/generic'
-import validation from '@nixweb/nixloc-ui/src/store/modules/validation'
-import automation from '@nixweb/nixloc-ui/src/store/modules/automation'
-import report from '@nixweb/nixloc-ui/src/store/modules/report'
-import user from '@nixweb/nixloc-ui/src/store/modules/user'
-import util from '@nixweb/nixloc-ui/src/store/modules/util'
-
-import generateMoviment from './modules/generateMoviment'
-import paymentShared from './modules/paymentShared'
-import pdv from './modules/pdv'
-
-Vue.use(Vuex)
-
-export default new Vuex.Store({
-  plugins: [createPersistedState({ storage: window.sessionStorage, paths: ["user", "generateMoviment"] })],
-  modules: {
-    generic, validation, automation, user, report, generateMoviment, pdv, paymentShared, util
-  }
+import Vue from 'vue';
+import Vuex from 'vuex';
+
+import user from './modules/user'
+import generic from './modules/generic'
+import validation from './modules/validation'
+
+Vue.use(Vuex)
+
+export default new Vuex.Store({
+  modules: {
+    generic, validation, user
+  }
 })

package/src/components/modules/adm/company/Company.js

@@ -1,9 +0,0 @@
-export default class Company {
-    constructor() {
-        this.id = "";
-        this.logo = "";
-        this.person = {};
-        this.contact = {};
-        this.address = {};
-    }
-}

package/src/components/modules/adm/company/Company.vue

@@ -1,114 +0,0 @@
-<template>
-  <div>
-    <br />
-    <ImageUpload title="Carregar Logo" container="nixloc-logo-company" :width="300" :height="100" accepted=".jpg .png"
-      urlPost="/api/v1/adm/file-upload/upload" urlRemove="/api/v1/adm/file-upload/delete" :onLoad="updateImage"
-      v-model="company.logo" />
-    <br />
-    <Molded>
-      <Person :formName="formName" v-model="company.person" />
-      <br />
-      <Contact :formName="formName" v-model="company.contact" />
-      <br />
-      <Address :formName="formName" v-model="company.address" />
-    </Molded>
-    <br />
-  </div>
-</template>
-
-<script>
-import ImageUpload from "@nixweb/nixloc-ui/src/component/forms/ImageUpload";
-import Molded from "@nixweb/nixloc-ui/src/component/layout/Molded";
-
-import Person from "@nixweb/nixloc-ui/src/component/value-objects/Person.vue";
-import Contact from "@nixweb/nixloc-ui/src/component/value-objects/Contact.vue";
-import Address from "@nixweb/nixloc-ui/src/component/value-objects/Address.vue";
-
-import Company from "@/components/modules/adm/company/Company.js";
-
-import { mapState, mapGetters, mapActions, mapMutations } from "vuex";
-
-export default {
-  name: "Company",
-  components: {
-    Molded,
-    ImageUpload,
-    Contact,
-    Person,
-    Address,
-  },
-  data() {
-    return {
-      formName: "companyUpdate",
-      company: new Company(),
-      urlUpdate: "/api/v1/adm/company/update",
-      urlGetById: "/api/v1/adm/company/get-by-id",
-    };
-  },
-  created() {
-    this.getById();
-  },
-  computed: {
-    ...mapState("user", ["userLogged"]),
-    ...mapGetters("validation", ["isFormValid"]),
-    ...mapGetters("generic", ["event"]),
-  },
-  methods: {
-    ...mapActions("generic", ["getApi", "putApi"]),
-    ...mapMutations("generic", ["addLoading", "removeLoading"]),
-    ...mapMutations("validation", ["resetValidation", "removeFormDirty"]),
-    getById() {
-      let params = {
-        url: this.urlGetById,
-        obj: { id: this.userLogged.companyId },
-      };
-      this.getApi(params).then((response) => {
-        this.company.logo = response.content.logo;
-        this.company.person = response.content.personResponse;
-        this.company.contact = response.content.contactResponse;
-        this.company.address = response.content.addressResponse;
-        let self = this;
-        setTimeout(function () {
-          self.removeLoading(["panel"]);
-          self.removeFormDirty();
-        }, 100);
-      });
-    },
-    update() {
-      let companyRequest = {
-        id: this.userLogged.companyId,
-        logo: this.company.logo,
-        personRequest: this.company.person,
-        contactRequest: this.company.contact,
-        addressRequest: {
-          zipCode: this.company.address.zipCode,
-          street: this.company.address.street,
-          number: this.company.address.number,
-          complement: this.company.address.complement,
-          province: this.company.address.province,
-          city: this.company.address.city,
-          state: this.company.address.state.content,
-        },
-      };
-      let params = { url: this.urlUpdate, obj: companyRequest };
-      this.putApi(params).then((response) => {
-        this.removeLoading(["saveSaveCancel"]);
-      });
-    },
-    updateImage() {
-      this.update();
-    },
-  },
-  watch: {
-    event: {
-      handler(event) {
-        if (event.name == "saveSaveCancel") {
-          this.update();
-        }
-      },
-      deep: true,
-    },
-  },
-};
-</script>
-<style scoped></style>

package/src/components/modules/adm/document/Document.js

@@ -1,41 +0,0 @@
-export default class Document {
-    constructor() {
-        this.id = "";
-        this.identification = "";
-        this.name = "";
-        this.module = [];
-        this.container = "nixloc-document-v2";
-        this.config = { product: { group: false, orderBy: 'default', show: [] }, moviment: { group: false, orderBy: 'default', show: [] } };
-        this.imageWatermark = "";
-        this.imageWidth = 0;
-        this.imageHeight = 0;
-        this.verticalAlignment = 0;
-        this.horizontalAlignment = 1;
-        this.opacity = 0;
-        this.styleCss = "";
-        this.showPages = false;
-        this.marginTop = 0;
-        this.marginLeft = 0;
-        this.marginRight = 0;
-        this.marginBottom = 0;
-    }
-    update(data) {
-        this.id = data.id;
-        this.identification = data.identification;
-        this.name = data.name;
-        this.module = data.module;
-        this.config = data.config;
-        this.imageWatermark = data.imageWatermark;
-        this.imageWidth = data.imageWidth;
-        this.imageHeight = data.imageHeight;
-        this.verticalAlignment = data.verticalAlignment;
-        this.horizontalAlignment = data.horizontalAlignment;
-        this.opacity = data.opacity;
-        this.styleCss = data.styleCss;
-        this.showPages = data.showPages;
-        this.marginTop = data.marginTop;
-        this.marginLeft = data.marginLeft;
-        this.marginRight = data.marginRight;
-        this.marginBottom = data.marginBottom;
-    }
-}