@nixweb/nixloc-ui 0.0.121 → 0.0.124

package/src/store/modules/report.js

@@ -0,0 +1,246 @@
+import ConvertToOdata from "@nixweb/nixloc-ui/src/component/shared/query-builder/ConvertToOdata.js";
+
+export default {
+    namespaced: true,
+    state: {
+        report: {
+            fields: [],
+            rules: [],
+        },
+        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);
+            });
+            return list;
+        },
+        optionTable: (state) => {
+            // optionsInitValue é quando vem da query salva pelo usuário
+            state.optionTable = {
+                initialValue: [],
+                options: []
+            };
+
+            var hasInitValue = state.optionsInitValue.length;
+
+            state.report.fields.forEach(function (field) {
+                let option = { text: field.title, value: field.value };
+                state.optionTable.options.push(option);
+
+                if (field.show && hasInitValue == 0)
+                    state.optionTable.initialValue.push(option);
+
+                if (hasInitValue > 0)
+                    state.optionTable.initialValue = state.optionsInitValue;
+            });
+
+            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;
+        },
+        oDataOrderBy: (state) => {
+            let orderBy = `$orderby=${state.campoOrdenado.id} ${state.campoOrdenado.ordenar}`;
+            return "";
+        },
+        oDataSelect: (state) => {
+            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++;
+                }
+            });
+            return query;
+        },
+        oDataFilter: (state) => {
+            let query = "";
+            let totalization = "";
+            let indexQuery = 0;
+            let indexTotalization = 0;
+            var size = state.queryOData.fields.length;
+            var andOr = [];
+
+            state.queryOData.fields.forEach(function (rule) {
+                if (rule.type == "field") {
+                    if (indexQuery == 0 && size > 0) query += `$filter=${rule.formatOdata}`;
+
+                    if (indexQuery > 0 && size > 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++;
+                }
+            });
+            return { query, totalization };
+        },
+        tags: (state) => {
+
+            state.tags = [];
+            let description = "";
+
+            state.queryOData.fields.forEach(function (rule) {
+                if (rule.fieldType == "dateTime") {
+                    description = `${rule.value[0]} - ${rule.value[1]}`;
+                }
+
+                if (rule.fieldType == "select") {
+                    description = rule.value.content;
+                }
+
+                if (rule.fieldType == "text" || rule.fieldType == "numeric") {
+                    description = `${rule.operator} "${rule.value}"`;
+                }
+
+                if (rule.fieldType == "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;
+        }
+    },
+    mutations: {
+        addFieldsReport: (state, fields) => {
+            state.report.fields = fields;
+        },
+        addRulesReport: (state, rules) => {
+            state.report.rules = rules;
+        },
+        addSelectedRules: (state, selectedRule) => {
+            state.query_builder.rules.push(selectedRule);
+        },
+        removeSelectedRule: (state, id) => {
+            var filter = state.query_builder.rules.filter((item) => {
+                return id != item.id;
+            })
+            state.query_builder.rules = filter;
+        },
+        updateSelectedField: (state, value) => {
+            state.selectedField = value;
+        },
+        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: [],
+            };
+
+            rules.forEach(function (rule) {
+
+                /*  if (key.query.choices && key.query.type == "totalization") {
+                      key.query.choices.forEach(function (value) {
+                          let obj = {
+                              title: value.como.title,
+                              value: value.como.value,
+                              classCss: key.query.classCss,
+                              type: value.como.type,
+                          };
+                          state.totalization.push(obj);
+                      });
+                  }*/
+
+
+                if (rule.value != null && rule.value != "" && rule.value != undefined) {
+
+                    let convertToOdata = new convertToOdata();
+                    let formatOdata = convertToOdata.ConvertToOdata(rule);
+
+                    let ruleOdata = {
+                        id: rule.id,
+                        title: rule.title,
+                        type: rule.type,
+                        fieldType: rule.fieldType,
+                        options: rule.options,
+                        operator: rule.operator,
+                        show: rule.show,
+                        isRequired: rule.isRequired,
+                        formatOdata: formatOdata,
+                        andOr: rule.andOr,
+                        value: rule.value,
+                    };
+
+                    state.queryOData.fields.push(ruleOdata);
+                }
+            });
+        }
+
+    },
+}

package/src/store/modules/user.js

@@ -0,0 +1,38 @@
+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;
+        },
+        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 = [];
+        },
+    },
+}

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,14 +1,14 @@
 import Vue from 'vue';
 import Vuex from 'vuex';
 
-import usuario from './modulos/usuario'
-import generic from './modulos/generic'
-import validation from './modulos/validation'
+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, usuario
+    generic, validation, user
   }
 })

package/src/component/forms/ArquivoUpload.vue

@@ -1,199 +0,0 @@
-<template>
-  <div>
-    <div>
-      <div class="arquivo" v-if="!value">
-        <button class="botao pequeno primario">
-          <span v-if="!carregandoAdicionar">
-            <i class="fas fa-cloud-upload-alt"></i> {{ titulo }}</span
-          >
-          <vue-loading
-            v-if="carregandoAdicionar"
-            type="bubbles"
-            color="#fff"
-            :size="{ width: '20px', height: '20px' }"
-          ></vue-loading>
-        </button>
-        <input
-          type="file"
-          name="myfile"
-          ref="arquivo"
-          :accept="aceitos"
-          v-on:change="carregar()"
-        />
-      </div>
-      <div v-if="value">
-        <button
-          class="botao pequeno sucesso"
-          @click="baixar()"
-          v-if="!carregandoAdicionar"
-        >
-          <i class="fas fa-cloud-download-alt"></i> Baixar
-        </button>
-        <button
-          class="botao pequeno perigo"
-          v-if="!carregandoAdicionar"
-          @click="remover()"
-        >
-          <span v-if="!carregandoRemover">Remover</span>
-          <vue-loading
-            v-if="carregandoRemover"
-            type="bubbles"
-            color="#fff"
-            :size="{ width: '20px', height: '20px' }"
-          ></vue-loading>
-        </button>
-      </div>
-      <div class="div-alerta">
-        <Alerta tipo="info" v-if="value">
-          <span>{{ mensagem }}</span>
-        </Alerta>
-      </div>
-    </div>
-  </div>
-</template>
-
-<script>
-import Alerta from "../layout/Alerta.vue";
-
-import { mapActions } from "vuex";
-
-export default {
-  name: "ArquivoUpload",
-  components: { Alerta },
-  props: {
-    titulo: String,
-    nome: String,
-    container: String,
-    aceitos: String,
-    mensagem: String,
-    urlAdicionar: String,
-    urlRemover: String,
-    nomeBancoDados: String,
-    aoCarregar: Function,
-    value: String,
-  },
-  data() {
-    return {
-      arquivo: "",
-      carregandoAdicionar: false,
-      carregandoRemover: false,
-      urlAzure: "https://espaco.blob.core.windows.net",
-    };
-  },
-  methods: {
-    ...mapActions("generic", ["postFileApi", "deleteFileApi"]),
-    carregar() {
-      this.arquivo = this.$refs.arquivo.files[0];
-      let params = {
-        url: this.urlAdicionar,
-        arquivo: this.arquivo,
-        container: this.container,
-        nome: this.nome,
-        aceitos: this.aceitos,
-      };
-      this.carregandoAdicionar = true;
-      this.postFileApi(params).then((response) => {
-        if (response.sucesso) {
-          if (this.aoCarregar) this.aoCarregar();
-          this.$emit("input", response.conteudo);
-        } else {
-          this.limpar();
-        }
-        this.carregandoAdicionar = false;
-      });
-    },
-    remover() {
-      let props = {
-        url: this.urlRemover,
-        container: this.container,
-        nome: this.nomeBancoDados,
-      };
-      this.carregandoRemover = true;
-      let params = { url: this.urlRemover, obj: props };
-      this.deleteFileApi(params).then((response) => {
-        if (response.sucesso) {
-          if (this.aoCarregar) this.aoCarregar();
-          this.limpar();
-          this.$emit("input", "");
-        }
-        this.carregandoRemover = false;
-      });
-    },
-    limpar() {
-      this.arquivo = "";
-    },
-    baixar() {
-      const url = `${this.urlAzure}/${this.container}/${this.nomeBancoDados}`;
-      window.location.href = url;
-    },
-  },
-};
-</script>
-
-<style scoped>
-.arquivo {
-  position: relative;
-  overflow: hidden;
-  display: inline-block;
-  cursor: pointer;
-}
-
-.botao {
-  padding: 8px 12px;
-  cursor: pointer;
-  border: none;
-  border-radius: 40px !important;
-  font-size: 14px;
-  font-weight: 400;
-}
-
-.primario {
-  background: #577696;
-  border-color: #577696;
-  color: #fff;
-}
-
-.primario:hover {
-  background: #355472;
-}
-
-.sucesso {
-  color: #fff;
-  background: #94aa2a;
-  border-color: #94aa2a;
-}
-
-.sucesso:hover {
-  background: #6d7e1c;
-}
-
-.perigo {
-  color: #fff;
-  border-color: #f0134d;
-  background: #f0134d;
-  margin-left: 5px;
-}
-
-.perigo:hover {
-  background: #c70f40;
-}
-
-.pequeno {
-  padding: 5px 10px;
-  font-size: 13px;
-}
-
-.arquivo input[type="file"] {
-  font-size: 100px;
-  position: absolute;
-  left: 0;
-  top: 0;
-  opacity: 0;
-}
-
-.div-alerta{
-  margin-top:15px;
-}
-
-
-</style>

package/src/component/forms/CheckboxMultiplo.vue

@@ -1,63 +0,0 @@
-<template>
-  <div>
-    <b-form-group :label="titulo">
-      <b-form-checkbox-group
-        v-model="selecionado"
-        :options="opcoes"
-        :stacked="empilhado"
-        @click.native="executar"
-      ></b-form-checkbox-group>
-    </b-form-group>
-  </div>
-</template>
-
-<script>
-import { mapState, mapMutations } from "vuex";
-
-export default {
-  name: "CheckboxMultiplo",
-  props: {
-    titulo: String,
-    opcoes: Array,
-    params: Object,
-    alterou: Function,
-    clicou: Function,
-    valorInicial: Array,
-    value: Array,
-    empilhado: {
-      type: Boolean,
-      default: false,
-    },
-    marcarFormSujo: {
-      type: Boolean,
-      default: true,
-    },
-  },
-  data() {
-    return {
-      selecionado: [],
-    };
-  },
-  mounted() {
-    this.selecionado = this.valorInicial;
-  },
-  methods: {
-    ...mapMutations("validation", ["insereFormSujo"]),
-    executar(event) {
-      if (this.marcarFormSujo) this.insereFormSujo(true);
-      this.$emit("input", this.selecionado);
-      let self = this;
-      setTimeout(function () {
-        // adicionado o pointerId para prevenir que não seja executado em duplicidade
-        if (self.clicou && event.pointerId === 1) self.clicou(self.params);
-      }, 100);
-    },
-  },
-  watch: {
-    selecionado() {
-      this.$emit("input", this.selecionado);
-      if (this.alterou) this.alterou(this.params);
-    },
-  },
-};
-</script>