@nixweb/nixloc-ui 0.0.119 → 0.0.122

package/src/store/modules/generic.js

@@ -0,0 +1,489 @@
+import axios from "@/config/axios";
+import tips from "@/config/dicas";
+import Token from "@nixweb/nixloc-ui/src/config/token";
+
+export default {
+    namespaced: true,
+    state: {
+        modal: {
+            name: undefined,
+            open: false
+        },
+        vodal: {
+            name: undefined,
+            open: false
+        },
+        notifications: [],
+        pagination: [],
+        selected: [],
+        loading: [],
+        event: {
+            dateTime: undefined,
+            name: undefined,
+            data: {}
+        },
+        toast: {
+            dateTime: undefined,
+            type: undefined,
+        },
+        ids: undefined,
+        search: { content: "", filter: { text: "Contém", value: "contem" } },
+        documentHtml: "",
+        selectStatic: { dateTime: undefined, targetField: undefined, value: undefined },
+        executedSearch: false,
+        clearedSearch: false,
+        methodExecutedApi: undefined,
+    },
+    getters: {
+        showModal: (state) => (name) => {
+            if (name == state.modal.name) return true;
+            return false;
+        },
+        showVodal: (state) => (name) => {
+            if (name == state.vodal.name) return true;
+            return false;
+        },
+        isLoading: (state) => (key) => {
+            var loading = state.loading.find(value => {
+                return value === key
+            })
+            if (loading) return true;
+            return false;
+        },
+        pagination: (state) => (key) => {
+            return state.pagination.find(obj => {
+                return obj.key === key
+            })
+        },
+        tip: (state) => (obj) => {
+            return tips.find(value => {
+                if (value.formName == obj.formName && value.field == obj.field)
+                    return value
+            })
+        },
+        event: (state) => {
+            return state.event;
+        },
+        documentPreview: (state) => {
+            let documentHtml = state.documentHtml
+            let ret = documentHtml;
+
+            var tables = document.getElementsByTagName("table");
+            let total = tables.length;
+
+            let config = [];
+
+            let index = 0;
+            while (index <= total - 1) {
+
+                let table = document.getElementsByTagName("table")[index];
+                let th = table.getElementsByTagName("th")[0];
+
+                let obj = {
+                    vForGrouped: "",
+                    vForSimple: "",
+                    nameGroup: "",
+                    nameGroupReplace: ""
+                };
+
+                if (th) {
+                    let isGrouped = th.innerText.includes("n.grupo");
+                    let isProduct = th.innerText.includes("n.produto");
+                    let isPeriod = th.innerText.includes("n.periodo");
+                    let isPayment = th.innerText.includes("n.pagamento");
+
+                    if (isProduct) {
+                        obj.vForSimple = "v-for='p in d.produto'";
+                        config.push(obj);
+                    } else if (isPeriod) {
+                        obj.vForSimple = "v-for='pe in d.periodo'";
+                        config.push(obj);
+                    } else if (isPayment) {
+                        obj.vForSimple = "v-for='pg in d.pagamento'";
+                        config.push(obj);
+                    } else if (isGrouped) {
+                        obj.vForGrouped = "v-for='(produto, grN) in produtoAgrupado'";
+                        obj.vForSimple = "v-for='p in d.produto'";
+
+                        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>"));
+
+                        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 {
+                        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(`ret${replace}`);
+
+            var classImportant = retParse
+                .replaceAll("n.grupo", "")
+                .replaceAll("n.produto", "")
+                .replaceAll("n.periodo", "")
+                .replaceAll("n.pagamento", "")
+                .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;
+        },
+    },
+    mutations: {
+        openModal: (state, name) => {
+            state.modal.name = name;
+            state.modal.open = true;
+        },
+        hideModal: (state) => {
+            state.modal.open = false;
+        },
+        openVodal: (state, name) => {
+            state.vodal.name = name;
+            state.vodal.open = true;
+        },
+        hideVodal: (state) => {
+            state.vodal.name = "";
+            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
+        },
+        addSelection: (state, selected) => {
+            state.selected = selected;
+        },
+        addToast: (state, action) => {
+            state.toast.dateTime = new Date();
+            state.toast.type = action;
+        },
+        addMethodExecutedApi: (state, action) => {
+            state.methodExecutedApi = action;
+        },
+        cleanMethodExecutedApi: (state) => {
+            state.methodExecutedApi = "";
+        },
+        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;
+            });
+        },
+        addPagination: (state, pagination) => {
+            state.pagination.push(pagination);
+        },
+        updatePagination: (state, pagination) => {
+            state.pagination.forEach(function (obj) {
+                if (obj.key == pagination.key)
+                    obj.totalPerPage = pagination.totalPerPage;
+            });
+        },
+        updateDocumentHtml: (state, value) => {
+            state.documentHtml = value;
+        },
+        addEvent: (state, obj) => {
+            state.event.dateTime = new Date();
+            state.event.name = obj.name;
+            state.event.data = obj.data;
+        },
+        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) => {
+            state.selectStatic.dateTime = new Date();
+            state.selectStatic.targetField = obj.targetField;
+            state.selectStatic.value = obj.value;
+        },
+
+    },
+    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');
+                        context.commit('validation/removeFormDirty', null, { root: true });
+                        return response.data;
+                    } else {
+
+                        context.commit('addNotifications', response.data.notifications)
+                        context.commit('addToast', 'postApiError');
+                        return response.data;
+                    }
+                }, (err) => {
+                    if (err.response)
+                        if (err.response.status === 403)
+                            context.commit('addNotifications', [{ message: "Usuário sem permissão para adicionar!" }])
+
+                    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('addToast', 'putApiErro');
+                        context.commit('addNotifications', response.data.notifications)
+                        return response.data;
+                    }
+                }, (err) => {
+                    if (err.response)
+                        if (err.response.status === 403)
+                            context.commit('addNotifications', [{ message: "Usuário sem permissão para modificar!" }])
+
+                    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;
+                })
+        },
+        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;
+                })
+        },
+        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', 'deleteApiErro');
+                        return response.data;
+                    }
+
+                }, (err) => {
+                    if (err.response)
+                        if (err.response.status === 403)
+                            context.commit('addNotifications', [{ message: "Usuário sem permissão para remover!" }])
+
+                    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', 'deleteApiErro');
+                        return response.data;
+                    }
+
+                }, (err) => {
+                    if (err.response)
+                        if (err.response.status === 403)
+                            context.commit('addNotifications', [{ message: "Usuário sem permissão para remover!" }])
+
+                    if (!err.response)
+                        context.commit('addNotificationErrorApi');
+                    return false;
+                })
+        },
+        getFileApi: 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" }),
+                        url = window.URL.createObjectURL(blob);
+                    window.open(url);
+                    context.commit('addMethodExecutedApi', 'getPdfApi');
+                    context.commit('removeNotificarions');
+
+                }, (err) => {
+                    context.commit('addNotificationErrorApi');
+                    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('addToast', 'addApiError');
+                        context.commit('addNotifications', response.data.notifications)
+
+                        return response.data;
+                    }
+                }, (err) => {
+                    if (err.response)
+                        if (err.response.status === 403)
+                            context.commit('addNotifications', [{ message: "Usuário sem permissão para adicionar!" }])
+
+                    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 remover!" }])
+
+                    if (!err.response)
+                        context.commit('addNotificationErrorApi');
+                    return false;
+                })
+        },
+    }
+}