@nixweb/nixloc-ui 0.0.273 → 0.0.274

package/src/store/modules/generic.js

@@ -0,0 +1,764 @@
+import axios from "@/config/axios";
+import Tips from "@/config/tips";
+import Token from "@nixweb/nixloc-ui/src/config/token";
+
+export default {
+    namespaced: true,
+    state: {
+        modal: {
+            name: undefined,
+            open: false
+        },
+        vodal: {
+            name: [],
+            open: false
+        },
+        sideBar: {
+            name: undefined,
+            open: false
+        },
+        notifications: [],
+        pagination: [],
+        paginations: { currentPage: 1, totalPerPage: 10 },
+        totalPerPage: { "content": "10", "id": 10 },
+        selected: [],
+        loading: [],
+        event: {
+            dateTime: undefined,
+            name: undefined,
+            data: {}
+        },
+        toast: {
+            dateTime: undefined,
+            type: undefined,
+        },
+        ids: undefined,
+        search: { content: "", filter: { content: "Contém", id: "contains" } },
+        documentHtml: "",
+        selectStatic: { dateTime: undefined, tag: undefined, fieldTarget: undefined, value: undefined },
+        tags: [],
+        executedSearch: false,
+        clearedSearch: false,
+        methodExecutedApi: undefined,
+        filterStorage: [],
+        filterQuery: [],
+        queryTags: [],
+    },
+    getters: {
+        tip: (state) => (tipId) => {
+            var tips = new Tips();
+            let message = "";
+            tips.help.find(value => {
+                if (value.tipId == tipId)
+                    message = value.message;
+            })
+            return message;
+        },
+        showModal: (state) => (name) => {
+            if (name == state.modal.name) return true;
+            return false;
+        },
+        showVodal: (state) => (name) => {
+            return state.vodal.name.includes(name);
+        },
+        isLoading: (state) => (key) => {
+            var loading = state.loading.find(value => {
+                return value === key
+            })
+            if (loading) return true;
+            return false;
+        },
+        getFilterStorage: (state) => (key) => {
+            return state.filterStorage.find(x => x.key === key);
+        },
+        getQueryFilter: (state) => (routeName) => {
+            return state.filterQuery.find(x => x.routeName === routeName);
+        },
+        paramsFilterStorage: (state) => (route, key, returnIfNull) => {
+            var filter = state.filterStorage.find(x => x.key === route);
+
+            if (filter) {
+                var obj = filter.paramsFilter.find(x => x.key === key);
+                if (obj) return obj.value;
+                return returnIfNull;
+            }
+            return returnIfNull;
+        },
+        pagination: (state) => (key) => {
+            return state.pagination.find(obj => {
+                return obj.key === key
+            })
+        },
+        event: (state) => {
+            return state.event;
+        },
+        documentPreview: (state) => (env) => {
+            let documentHtml = state.documentHtml
+            let ret = documentHtml;
+
+            var template = null;
+
+            if (env == 'dev')
+                template = document.getElementById("template-dev");
+
+            if (env == 'prod')
+                template = document.getElementById("template-prod");
+
+            if (template != null) {
+                var tables = template.getElementsByTagName("table");
+                let total = tables.length;
+                let config = [];
+
+                let index = 0;
+                while (index <= total - 1) {
+
+                    let table = template.getElementsByTagName("table")[index];
+                    let th = table.getElementsByTagName("th")[0];
+
+                    let obj = {
+                        vForGrouped: "",
+                        vForSimple: "",
+                        nameGroup: "",
+                        nameGroupReplace: ""
+                    };
+
+                    if (th) {
+
+                        let isPayment = th.innerText.includes("t.pagamentoLocacao");
+                        let isPeriod = th.innerText.includes("t.periodoLocacao");
+                        let isProduct = th.innerText.includes("t.produtoLocacao");
+                        let isInvoice = th.innerText.includes("t.produtoFatura");
+                        let isGrouped = th.innerText.includes("t.produtoAgrupado");
+                        let isMoviment = th.innerText.includes("t.produtoMovimentacao");
+                        let isCustumerAddress = th.innerText.includes("t.enderecoCliente");
+                        let isAddressRent = th.innerText.includes("t.saidaRetornoLocacao");
+                        let isTeamRent = th.innerText.includes("t.equipeLocacao");
+
+
+                        if (isProduct) {
+                            obj.vForSimple = "v-for='produto in d.itensLocacao'";
+                            config.push(obj);
+                        } else if (isInvoice) {
+                            obj.vForSimple = "v-for='produto in d.itensFatura'";
+                            config.push(obj);
+                        } else if (isPeriod) {
+                            obj.vForSimple = "v-for='periodo in d.periodoLocacao'";
+                            config.push(obj);
+                        } else if (isPayment) {
+                            obj.vForSimple = "v-for='pagamento in d.pagamentoLocacao'";
+                            config.push(obj);
+                        } else if (isTeamRent) {
+                            obj.vForSimple = "v-for='equipe in d.equipeLocacao'";
+                            config.push(obj);
+                        } else if (isGrouped) {
+                            obj.vForGrouped = "v-for='(itensLocacao, grupo) in produtoAgrupado'";
+                            obj.vForSimple = "v-for='produto in itensLocacao'";
+
+                            // neste cenário basicamente temos que montar o <tbody> no array de agrupamento
+
+                            var initIndex = documentHtml.split("<tbody>", index + 1).join("<tbody>").length;
+                            var lastIndex = documentHtml.split("</tbody>", index + 1).join("</tbody>").length;
+
+                            let tbody = documentHtml.substring(documentHtml.indexOf("<tbody>", initIndex), documentHtml.lastIndexOf("</tbody>", lastIndex));
+
+                            let tr = tbody.substring(tbody.indexOf("<tr>"), tbody.lastIndexOf("</tr>"));
+
+                            // faz o replace nameGroup para tirar o <tr/>
+                            obj.nameGroup = tr.substring(0, tr.indexOf('</tr>')) + "</tr>";
+                            obj.nameGroup = obj.nameGroup.replaceAll("\"", "'");
+                            obj.nameGroupReplace = obj.nameGroup.replace("<tr>", "").replace("</tr>", "");
+
+                            config.push(obj);
+
+                        } else if (isMoviment) {
+                            obj.vForSimple = "v-for='produto in d.itensMovimentacao'";
+                            config.push(obj);
+                        } else if (isCustumerAddress) {
+                            obj.vForSimple = "v-for='endereco in d.locacao.cliente.endereco'";
+                            config.push(obj);
+                        } else if (isAddressRent) {
+                            obj.vForSimple = "v-for='endereco in d.saidaRetorno'";
+                            config.push(obj);
+                        } else {
+                            config.push(obj);
+                        }
+                    } else {
+                        config.push(obj);
+                    }
+                    index++;
+                }
+
+                let replace = "";
+                config.forEach(x => {
+                    replace += `.replace("<tbody>${x.nameGroup}<tr>", "<tbody ${x.vForGrouped}>${x.nameGroupReplace}<tr ${x.vForSimple}>")`;
+                });
+
+                var retParse = ret.replaceAll("\"", "'");
+                retParse = eval(`retParse${replace}`);
+
+                var classImportant = retParse
+                    .replaceAll("t.pagamentoLocacao", "")
+                    .replaceAll("t.periodoLocacao", "")
+                    .replaceAll("t.produtoLocacao", "")
+                    .replaceAll("t.produtoFatura", "")
+                    .replaceAll("t.produtoAgrupado", "")
+                    .replaceAll("t.produtoMovimentacao", "")
+                    .replaceAll("t.enderecoCliente", "")
+                    .replaceAll("t.saidaRetornoLocacao", "")
+                    .replaceAll("t.equipeLocacao", "")
+                    .replaceAll("<p>&nbsp!important;</p>", "<p>&nbsp</p>");
+            }
+
+            return classImportant;
+        },
+        groupBy: () => (obj) => {
+            const result = {};
+            obj.array.forEach((item) => {
+                if (!result[item[obj.key]]) {
+                    result[item[obj.key]] = [];
+                }
+                result[item[obj.key]].push(item);
+            });
+            return result;
+        },
+        listIdToString: () => (listId) => {
+            var ids = "";
+            listId.forEach(function (id) {
+                ids += `${id},`;
+            });
+            return ids;
+        },
+    },
+    mutations: {
+        openModal: (state, name) => {
+            state.modal.name = name;
+            state.modal.open = true;
+        },
+        hideModal: (state) => {
+            state.modal.open = false;
+        },
+        openSideBar: (state, name) => {
+            state.sideBar.name = name;
+            state.sideBar.open = true;
+        },
+        hideSideBar: (state) => {
+            state.sideBar.open = false;
+        },
+        openVodal: (state, name) => {
+            state.vodal.name.push(name);
+            state.vodal.open = true;
+        },
+        hideVodal: (state, name) => {
+            let filter = state.vodal.name.filter(x => x != name);
+            state.vodal.name = filter;
+            state.vodal.open = false;
+        },
+        updateSearch: (state, value) => {
+            state.search = value;
+        },
+        executedSearch: (state) => {
+            state.executedSearch = state.executedSearch = !state.executedSearch
+        },
+        clearedSearch: (state) => {
+            state.clearedSearch = state.clearedSearch = !state.clearedSearch
+        },
+        updateCurrentPage: (state, value) => {
+            state.paginations.currentPage = value;
+        },
+        updateTotalPerPage: (state, value) => {
+            state.paginations.totalPerPage = value.id;
+        },
+        addSelected: (state, selected) => {
+            state.selected = selected;
+        },
+        cleanSelected: (state) => {
+            setTimeout(function () {
+                state.selected = [];
+            }, 100);
+        },
+        addToast: (state, action) => {
+            state.toast.dateTime = new Date();
+            state.toast.type = action;
+        },
+        addMethodExecutedApi: (state, action) => {
+            setTimeout(function () {
+                state.methodExecutedApi = action;
+            }, 100);
+        },
+        cleanMethodExecutedApi: (state) => {
+            setTimeout(function () {
+                state.methodExecutedApi = "";
+            }, 100);
+        },
+        addLoading: (state, key) => {
+            state.loading.push(key);
+        },
+        removeLoading: (state, listKey) => {
+            listKey.forEach(function (key) {
+                let filter = state.loading.filter(function (item) {
+                    return item != key;
+                });
+                state.loading = filter;
+            });
+        },
+        updateDocumentHtml: (state, value) => {
+            state.documentHtml = value;
+        },
+        addEvent: (state, obj) => {
+            setTimeout(function () {
+                state.event.dateTime = new Date();
+                state.event.name = obj.name;
+                state.event.data = obj.data;
+            }, 100);
+        },
+        removeEvent: (state) => {
+            state.event = {};
+        },
+        addNotifications: (state, notifications) => {
+            state.notifications = notifications;
+        },
+        removeNotificarions: (state) => {
+            state.notifications = [];
+        },
+        addNotificationErrorApi: (state) => {
+            var erro = { property: "ERRO API", message: "Falha de Comunicação!" };
+            state.notifications = [erro];
+        },
+        listIdToString: (state, listId) => {
+            state.ids = "";
+            listId.forEach(function (id) {
+                state.ids += `${id},`;
+            });
+        },
+        addFilter: (state, obj) => {
+            setTimeout(function () {
+                state.selectStatic.dateTime = new Date();
+                state.selectStatic.tag = obj.tag;
+                state.selectStatic.fieldTarget = obj.fieldTarget;
+                state.selectStatic.value = obj.value;
+            }, 100);
+        },
+        addTag: (state, tag) => {
+            state.tags.push(tag);
+        },
+        removeTag: (state, key) => {
+            let filter = state.tags.filter(x => x.key != key);
+            state.tags = filter;
+        },
+        cleanTags: (state) => {
+            state.tags = []
+        },
+        openModal: (state, name) => {
+            state.modal.name = name;
+            state.modal.open = true;
+        },
+        addFilterStorage: (state, obj) => {
+            const index = state.filterStorage.findIndex(x => x.key === obj.key);
+            if (index !== -1) {
+                state.filterStorage[index] = obj;
+
+            } else {
+                state.filterStorage.push(obj);
+            }
+        },
+        removeFilterStorage: (state, key) => {
+            let filter = state.filterStorage.filter(x => x.key != key);
+            state.filterStorage = filter;
+        },
+        addFilterQuery: (state, obj) => {
+            // função abaixo é para não deixar duplicidade
+            const index = state.filterQuery.findIndex(x => x.routeName === obj.routeName);
+            if (index !== -1) {
+                state.filterQuery[index] = obj;
+
+            } else {
+                state.filterQuery.push(obj);
+            }
+        },
+        updateQueryTags: (state, tags) => {
+            state.queryTags = tags;
+        },
+    },
+    actions: {
+        postApi: async function (context, params) {
+            context.commit('cleanMethodExecutedApi');
+            return axios.post(params.url, params.obj, {
+                headers: new Token().tokenHeaders(),
+            })
+                .then((response) => {
+
+                    if (response.data.success) {
+                        context.commit('addMethodExecutedApi', 'postApi');
+
+                        if (!params.notNotifyToast)
+                            context.commit('addToast', 'postApi');
+
+                        context.commit('removeNotificarions');
+
+                        if (!params.notRemoveFormDirty)
+                            context.commit('validation/removeFormDirty', null, { root: true });
+
+                        return response.data;
+                    } else {
+
+                        context.commit('addNotifications', response.data.notifications)
+                        context.commit('addToast', 'messageError');
+
+                        return response.data;
+                    }
+                }, (err) => {
+
+                    if (err.response)
+                        if (err.response.status === 403) {
+                            context.commit('addNotifications', [{ message: "Usuário sem permissão para executar esta ação!" }])
+                            context.commit('addToast', 'noPermission');
+                        }
+
+                    if (!err.response)
+                        context.commit('addNotificationErrorApi');
+                    return false;
+                })
+        },
+        putApi: async function (context, params) {
+            context.commit('cleanMethodExecutedApi');
+            return axios.put(params.url, params.obj, {
+                headers: new Token().tokenHeaders(),
+            })
+                .then((response) => {
+                    if (response.data.success) {
+                        context.commit('addMethodExecutedApi', 'putApi');
+
+                        if (!params.notNotifyToast)
+                            context.commit('addToast', 'putApi');
+
+                        context.commit('removeNotificarions');
+                        context.commit('validation/removeFormDirty', null, { root: true });
+                        return response.data;
+                    } else {
+                        context.commit('addNotifications', response.data.notifications)
+                        context.commit('addToast', 'messageError');
+                        return response.data;
+                    }
+                }, (err) => {
+                    if (err.response)
+                        if (err.response.status === 403) {
+                            context.commit('addNotifications', [{ message: "Usuário sem permissão para executar esta ação!" }])
+                            context.commit('addToast', 'noPermission');
+                        }
+
+                    if (!err.response)
+                        context.commit('addNotificationErrorApi');
+
+                    return false;
+                })
+        },
+        getApi: async function (context, params) {
+
+            context.commit('cleanMethodExecutedApi');
+            return axios.get(params.url, {
+                params: params.obj,
+                headers: new Token().tokenHeaders(),
+            })
+                .then((response) => {
+
+                    if (response.data.success) {
+                        context.commit('addMethodExecutedApi', params.methodExecutedApi);
+                        context.commit('removeNotificarions');
+                        return response.data;
+                    } else {
+
+                        context.commit('addNotifications', response.data.notifications)
+                        context.commit('addToast', 'falhaGenerica');
+                        return response.data;
+                    }
+                }, (err) => {
+                    context.commit('addNotificationErrorApi');
+                    return false;
+                })
+        },
+        orderAllApi: async function (context, params) {
+            return axios.put(params.url, params.obj, {
+                headers: new Token().tokenHeaders(),
+            })
+                .then((response) => {
+                    return response.data;
+                }, (err) => {
+                    context.commit('addNotificationErrorApi');
+                    return false;
+                })
+        },
+        getApiOdata: async function (context, params) {
+            return axios.get(params.url, {
+                headers: new Token().tokenHeaders(),
+            })
+                .then((response) => {
+                    return response.data;
+                }, (err) => {
+                    context.commit('addNotificationErrorApi');
+                    return false;
+                })
+        },
+        putAllApi: async function (context, params) {
+
+            context.commit('cleanMethodExecutedApi');
+            context.commit('listIdToString', params.selected);
+
+            let ids = context.state.ids;
+
+            return axios.put(params.url, { ids: ids }, {
+                headers: new Token().tokenHeaders(),
+            })
+                .then((response) => {
+                    if (response.data.success) {
+                        context.commit('addMethodExecutedApi', 'putApi');
+                        context.commit('addToast', 'putAllApi');
+                        context.commit('removeNotificarions');
+                        context.commit('cleanSelected', 'putApi');
+
+                        return response.data;
+                    } else {
+                        context.commit('addNotifications', response.data.notifications)
+                        context.commit('addMethodExecutedApi', 'putApiErro');
+                        context.commit('addToast', 'messageError');
+                        return response.data;
+                    }
+
+                }, (err) => {
+                    if (err.response)
+                        if (err.response.status === 403) {
+                            context.commit('addNotifications', [{ message: "Usuário sem permissão para executar esta ação!" }])
+                            context.commit('addToast', 'noPermission');
+                        }
+
+                    if (!err.response)
+                        context.commit('addNotificationErrorApi');
+                    return false;
+                })
+        },
+        deleteAllApi: async function (context, params) {
+
+            context.commit('cleanMethodExecutedApi');
+            context.commit('listIdToString', params.selected);
+
+            let url = params.url;
+            let ids = context.state.ids;
+
+            return axios.delete(`${url}?ids=${ids}`, {
+                headers: new Token().tokenHeaders(),
+            })
+                .then((response) => {
+                    if (response.data.success) {
+                        context.commit('addMethodExecutedApi', 'deleteAllApi');
+                        context.commit('addToast', 'deleteApiSucesso');
+                        context.commit('removeNotificarions');
+                        return response.data;
+                    } else {
+                        context.commit('addNotifications', response.data.notifications)
+                        context.commit('addMethodExecutedApi', 'deleteAllApiErro');
+                        context.commit('addToast', 'messageError');
+                        return response.data;
+                    }
+
+                }, (err) => {
+                    if (err.response)
+                        if (err.response.status === 403) {
+                            context.commit('addNotifications', [{ message: "Usuário sem permissão para executar esta ação!" }])
+                            context.commit('addToast', 'noPermission');
+                        }
+
+                    if (!err.response)
+                        context.commit('addNotificationErrorApi');
+                    return false;
+                })
+        },
+        deleteApi: async function (context, params) {
+
+            context.commit('cleanMethodExecutedApi');
+            let url = params.url;
+
+            return axios.delete(`${url}`, {
+                headers: new Token().tokenHeaders(),
+            })
+                .then((response) => {
+                    if (response.data.success) {
+                        context.commit('addMethodExecutedApi', 'deleteApi')
+                        context.commit('addToast', 'deleteApiSucesso');
+                        context.commit('removeNotificarions');
+                        return response.data;
+                    } else {
+                        context.commit('addNotifications', response.data.notifications)
+                        context.commit('addToast', 'messageError');
+                        return response.data;
+                    }
+
+                }, (err) => {
+                    if (err.response)
+                        if (err.response.status === 403) {
+                            context.commit('addNotifications', [{ message: "Usuário sem permissão para executar esta ação!" }])
+                            context.commit('addToast', 'noPermission');
+                        }
+
+                    if (!err.response)
+                        context.commit('addNotificationErrorApi');
+                    return false;
+                })
+        },
+        getFileApi: async function (context, params) {
+            context.commit('cleanMethodExecutedApi');
+            return axios.get(params.url, {
+                params: params.obj,
+                headers: new Token().tokenHeaders(),
+                responseType: "arraybuffer",
+            })
+                .then((response) => {
+
+                    let blob = new Blob([response.data], { type: `application/${params.obj.fileType}` });
+                    let url = window.URL.createObjectURL(blob);
+
+                    let downloadLink = document.createElement("a");
+                    downloadLink.href = url;
+                    downloadLink.download = `${params.obj.fileName}`;
+
+                    document.body.appendChild(downloadLink);
+                    downloadLink.click();
+
+                    document.body.removeChild(downloadLink);
+
+                    context.commit('addMethodExecutedApi', 'getPdfApi');
+                    context.commit('removeNotificarions');
+
+                }, (err) => {
+                    context.commit('addNotificationErrorApi');
+                    return false;
+                })
+        },
+        getFileApiWithParameterBody: async function (context, params) {
+            context.commit('cleanMethodExecutedApi');
+            return axios.post(params.url, params.obj, {
+                headers: new Token().tokenHeaders(),
+                responseType: "arraybuffer",
+            })
+                .then((response) => {
+
+                    let blob = new Blob([response.data], { type: "application/pdf" });
+                    let url = window.URL.createObjectURL(blob);
+
+                    let downloadLink = document.createElement("a");
+                    downloadLink.href = url;
+                    downloadLink.download = `${params.obj.fileName}`;
+
+                    document.body.appendChild(downloadLink);
+                    downloadLink.click();
+
+                    document.body.removeChild(downloadLink);
+
+                }, (err) => {
+                    return false;
+                })
+        },
+        postFileApi: async function (context, params) {
+            context.commit('cleanMethodExecutedApi');
+
+            let formData = new FormData();
+            formData.append("file", params.file);
+            formData.append(params.container, params.container);
+            formData.append(params.name, params.name);
+            formData.append(params.accepted, params.accepted);
+
+            return axios.post(params.url, formData, {
+                headers: new Token().tokenHeaders(),
+            })
+                .then((response) => {
+                    if (response.data.success) {
+                        context.commit('addMethodExecutedApi', 'postFileApi');
+                        context.commit('removeNotificarions');
+                        return response.data;
+                    } else {
+
+                        context.commit('addNotifications', response.data.notifications)
+                        context.commit('addToast', 'messageError');
+
+                        return response.data;
+                    }
+                }, (err) => {
+                    if (err.response)
+                        if (err.response.status === 403) {
+                            context.commit('addNotifications', [{ message: "Usuário sem permissão para executar esta ação!" }])
+                            context.commit('addToast', 'noPermission');
+                        }
+
+                    if (!err.response)
+                        context.commit('addNotificationErrorApi');
+                    return false;
+                })
+        },
+        deleteFileApi: async function (context, params) {
+            context.commit('cleanMethodExecutedApi');
+
+            let url = params.url;
+            let name = params.obj.name;
+            let container = params.obj.container;
+
+            return axios.delete(`${url}?name=${name}&container=${container}`, {
+                headers: new Token().tokenHeaders(),
+            })
+                .then((response) => {
+                    if (response.data.success) {
+                        context.commit('addMethodExecutedApi', 'deleteFileApi');
+                        context.commit('removeNotificarions');
+                        return response.data;
+                    } else {
+                        context.commit('addNotifications', response.data.notifications)
+                        context.commit('addToast', 'addApiError');
+                        return response.data;
+                    }
+                }, (err) => {
+                    if (err.response)
+                        if (err.response.status === 403) {
+                            context.commit('addNotifications', [{ message: "Usuário sem permissão para executar esta ação!" }])
+                            context.commit('addToast', 'noPermission');
+                        }
+
+                    if (!err.response)
+                        context.commit('addNotificationErrorApi');
+                    return false;
+                })
+        },
+        getDocumentApi: async function (context, params) {
+            context.commit('cleanMethodExecutedApi');
+            return axios.get(params.url, {
+                params: params.obj,
+                headers: {
+                    "Content-Type": "application/json",
+                    Authorization: "Bearer " + params.obj.token
+                },
+            })
+                .then((response) => {
+                    if (response.data.success) {
+                        return response.data;
+                    } else {
+                        return response.data;
+                    }
+                }, (err) => {
+
+                    return false;
+                })
+        },
+        getPdfApi: async function (context, params) {
+            context.commit('cleanMethodExecutedApi');
+            return axios.get(params.url, {
+                params: params.obj,
+                responseType: "arraybuffer",
+                headers: new Token().tokenHeaders(),
+            })
+                .then((response) => {
+                    let blob = new Blob([response.data], { type: "application/pdf" }),
+                        url = window.URL.createObjectURL(blob);
+                    window.open(url);
+                }, (err) => {
+                    return false;
+                })
+        },
+
+    }
+}