godeep-states 1.0.0

package/dist/runtime/stores/login.js

@@ -0,0 +1,195 @@
+import { defineStore } from "pinia";
+import { useRouter } from "#imports";
+import { alerta } from "../utils/alerta.js";
+import { extrairMensagensErro } from "../utils/erros.js";
+import {
+  traduzirEsqueceuSenhaToken,
+  traduzirLoginResponse,
+  traduzirRedefinirSenha
+} from "godeep-types/translate";
+const usuarioDefault = {
+  id: 0,
+  nome: "",
+  email: "",
+  tipoCliente: "",
+  token: "",
+  cliente: {
+    sexo: "",
+    tipo: "",
+    validacaoCadastro: ""
+  }
+};
+export const storeLogin = defineStore("login", {
+  state: () => ({
+    esqueceuSenhaToken: {},
+    redefinirSenhaResposta: {},
+    usuario: usuarioDefault,
+    carregando: false,
+    dadosLembrarMe: null,
+    emailEnviado: false,
+    mensagemEsqueceuSenha: ""
+  }),
+  getters: {
+    recuperarUsuario: (state) => state.usuario,
+    usuarioCarregando: (state) => state.carregando,
+    recuperarEsqueceuSenhaToken: (state) => state.esqueceuSenhaToken,
+    recuperarRedefinirSenhaResposta: (state) => state.redefinirSenhaResposta
+  },
+  actions: {
+    resetarLogin() {
+      this.usuario = usuarioDefault;
+      this.esqueceuSenhaToken = {};
+      this.redefinirSenhaResposta = {};
+      this.carregando = false;
+      this.dadosLembrarMe = null;
+      this.emailEnviado = false;
+      this.mensagemEsqueceuSenha = "";
+    },
+    resetarEsqueceuSenha() {
+      this.esqueceuSenhaToken = {};
+      this.emailEnviado = false;
+      this.mensagemEsqueceuSenha = "";
+    },
+    async esqueceuSenha(email) {
+      try {
+        this.carregando = true;
+        this.mensagemEsqueceuSenha = "";
+        this.emailEnviado = false;
+        const router = useRouter();
+        const response = await $fetch(
+          "/api/front-api/esqueceu-senha-token",
+          {
+            method: "POST",
+            body: { email }
+          }
+        );
+        this.esqueceuSenhaToken = traduzirEsqueceuSenhaToken(response) ?? {};
+        const mensagemSucesso = "Email de recupera\xE7\xE3o enviado com sucesso. Verifique sua caixa de entrada.";
+        this.emailEnviado = true;
+        this.mensagemEsqueceuSenha = mensagemSucesso;
+        alerta.adicionar({
+          titulo: "Sucesso",
+          descricao: mensagemSucesso,
+          cor: "success",
+          variantes: ["outline"]
+        });
+        setTimeout(() => {
+          router.push("/login");
+          this.resetarEsqueceuSenha();
+        }, 8e3);
+        return { sucesso: true, mensagem: mensagemSucesso };
+      } catch (error) {
+        this.esqueceuSenhaToken = {};
+        this.emailEnviado = false;
+        const { mensagemGeral } = extrairMensagensErro(
+          error,
+          "Erro ao solicitar recupera\xE7\xE3o de senha"
+        );
+        this.mensagemEsqueceuSenha = mensagemGeral;
+        alerta.adicionar({
+          titulo: "Erro",
+          descricao: mensagemGeral,
+          cor: "error",
+          variantes: ["outline"]
+        });
+        return { sucesso: false, mensagem: mensagemGeral };
+      } finally {
+        this.carregando = false;
+      }
+    },
+    async redefinirSenha(email, token, senha, confirmarSenha) {
+      try {
+        this.carregando = true;
+        if (senha !== confirmarSenha) {
+          this.esqueceuSenhaToken = {};
+          this.carregando = false;
+          alerta.adicionar({
+            titulo: "Erro",
+            descricao: "As senhas n\xE3o coincidem",
+            cor: "error",
+            variantes: ["outline"]
+          });
+          return;
+        }
+        const response = await $fetch(
+          "/api/front-api/redefinir-senha",
+          {
+            method: "POST",
+            body: { email, token, senha, confirmarSenha }
+          }
+        );
+        const redefinirSenhaTraduzido = traduzirRedefinirSenha(response);
+        this.redefinirSenhaResposta = redefinirSenhaTraduzido ?? {};
+        if (redefinirSenhaTraduzido?.mensagem) {
+          alerta.adicionar({
+            titulo: "Sucesso",
+            descricao: redefinirSenhaTraduzido.mensagem,
+            cor: "success",
+            variantes: ["outline"]
+          });
+        }
+      } catch (error) {
+        this.redefinirSenhaResposta = {};
+        alerta.adicionar({
+          titulo: "Erro",
+          descricao: extrairMensagensErro(error, "Erro ao redefinir senha").mensagemGeral,
+          cor: "error",
+          variantes: ["outline"]
+        });
+      } finally {
+        this.carregando = false;
+      }
+    },
+    async login(email, senha, lembrarMe = false) {
+      try {
+        this.carregando = true;
+        const router = useRouter();
+        const response = await $fetch(
+          "/api/front-api/login",
+          {
+            method: "POST",
+            body: { email, senha }
+          }
+        );
+        const usuarioTraduzido = traduzirLoginResponse(response);
+        if (usuarioTraduzido?.token) {
+          console.log(usuarioTraduzido, "usuarioTraduzido");
+          this.usuario = usuarioTraduzido;
+          if (lembrarMe) {
+            this.dadosLembrarMe = { email, senha };
+          } else {
+            this.dadosLembrarMe = null;
+          }
+          alerta.adicionar({
+            titulo: "Sucesso",
+            descricao: "Login realizado com sucesso",
+            cor: "success",
+            variantes: ["outline"]
+          });
+          setTimeout(() => {
+            router.push("/");
+          }, 2e3);
+        } else {
+          alerta.adicionar({
+            titulo: "Erro",
+            descricao: "Login n\xE3o realizado",
+            cor: "error",
+            variantes: ["outline"]
+          });
+        }
+      } catch (error) {
+        alerta.adicionar({
+          titulo: "Erro",
+          descricao: extrairMensagensErro(error, "Erro ao realizar login").mensagemGeral,
+          cor: "error",
+          variantes: ["outline"]
+        });
+      } finally {
+        this.carregando = false;
+      }
+    }
+  },
+  persist: {
+    storage: piniaPluginPersistedstate.sessionStorage()
+  }
+});

package/dist/runtime/stores/menus.d.ts

@@ -0,0 +1,5 @@
+import type { StorefrontMenu } from 'godeep-types/types';
+export declare const storeMenus: import("pinia").StoreDefinition<"menus", {
+    menus: StorefrontMenu;
+    carregando: boolean;
+}, {}, {}>;

package/dist/runtime/stores/menus.js

@@ -0,0 +1,35 @@
+import { traduzirMenu } from "godeep-types/translate";
+import { defineStore } from "pinia";
+export const storeMenus = defineStore("menus", {
+  state: () => ({
+    menus: {},
+    carregando: false
+  }),
+  getters: {
+    recuperarMenus: (state) => state.menus,
+    menuCarregando: (state) => state.carregando
+  },
+  actions: {
+    async resetarMenus() {
+      this.menus = {};
+      this.carregando = false;
+    },
+    async buscarMenus() {
+      try {
+        this.carregando = true;
+        const response = await $fetch(
+          "/api/front-api/menus"
+        );
+        const menuTraduzido = traduzirMenu(response);
+        this.menus = menuTraduzido ?? {};
+        this.carregando = false;
+      } catch {
+        this.menus = {};
+        this.carregando = false;
+      }
+    }
+  },
+  persist: {
+    storage: piniaPluginPersistedstate.sessionStorage()
+  }
+});

package/dist/runtime/stores/newsletter.d.ts

@@ -0,0 +1,6 @@
+import type { StorefrontNewsletterResposta } from 'godeep-types/types';
+export declare const storeNewsletter: import("pinia").StoreDefinition<"newsletter", {
+    email: string;
+    enviando: boolean;
+    resposta: StorefrontNewsletterResposta;
+}, {}, {}>;

package/dist/runtime/stores/newsletter.js

@@ -0,0 +1,80 @@
+import { traduzirNewsletterResposta } from "godeep-types/translate";
+import { defineStore } from "pinia";
+import { alerta } from "../utils/alerta.js";
+function validarEmail(email) {
+  const regex = /^[\w.%+-]+@[\w.-]+\.[a-z]{2,}$/i;
+  return regex.test(email);
+}
+export const storeNewsletter = defineStore("newsletter", {
+  state: () => ({
+    email: "",
+    enviando: false,
+    resposta: {}
+  }),
+  getters: {
+    recuperarEmail: (state) => state.email,
+    newsletterEnviando: (state) => state.enviando,
+    recuperarRespostaNewsletter: (state) => state.resposta
+  },
+  actions: {
+    resetarNewsletter() {
+      this.email = "";
+      this.enviando = false;
+      this.resposta = {};
+    },
+    async assinar(emailValor) {
+      const email = (emailValor ?? this.email).trim();
+      if (!email) {
+        alerta.adicionar({
+          titulo: "Email obrigat\xF3rio",
+          descricao: "Por favor, digite seu email.",
+          cor: "warning",
+          variantes: ["dashed", "soft"]
+        });
+        return { sucesso: false };
+      }
+      if (!validarEmail(email)) {
+        alerta.adicionar({
+          titulo: "Email inv\xE1lido",
+          descricao: "Por favor, digite um email v\xE1lido.",
+          cor: "warning",
+          variantes: ["dashed", "soft"]
+        });
+        return { sucesso: false };
+      }
+      this.enviando = true;
+      try {
+        const resposta = await $fetch(
+          "/api/front-api/newsletter",
+          {
+            method: "POST",
+            body: { email }
+          }
+        );
+        this.resposta = traduzirNewsletterResposta(resposta);
+        const mensagemSucesso = this.resposta.mensagens?.[0] ?? "Newsletter cadastrada!";
+        alerta.adicionar({
+          titulo: "Newsletter cadastrada!",
+          descricao: mensagemSucesso,
+          cor: "success",
+          variantes: ["dashed", "soft"]
+        });
+        this.email = "";
+        return { sucesso: true, resposta: this.resposta };
+      } catch (error) {
+        alerta.adicionar({
+          titulo: "Erro ao cadastrar",
+          descricao: "N\xE3o foi poss\xEDvel cadastrar seu email. Tente novamente.",
+          cor: "error",
+          variantes: ["dashed", "soft"]
+        });
+        return { sucesso: false, erro: error };
+      } finally {
+        this.enviando = false;
+      }
+    }
+  },
+  persist: {
+    storage: piniaPluginPersistedstate.sessionStorage()
+  }
+});

package/dist/runtime/stores/pagamentos.d.ts

@@ -0,0 +1,5 @@
+import type { StorefrontPagamentosDados } from 'godeep-types/types';
+export declare const storePagamentos: import("pinia").StoreDefinition<"pagamentos", {
+    pagamentos: StorefrontPagamentosDados[];
+    carregando: boolean;
+}, {}, {}>;

package/dist/runtime/stores/pagamentos.js

@@ -0,0 +1,35 @@
+import { traduzirPagamentos } from "godeep-types/translate";
+import { defineStore } from "pinia";
+export const storePagamentos = defineStore("pagamentos", {
+  state: () => ({
+    pagamentos: [],
+    carregando: false
+  }),
+  getters: {
+    recuperarPagamentos: (state) => state.pagamentos,
+    pagamentosCarregando: (state) => state.carregando
+  },
+  actions: {
+    async resetarPagamentos() {
+      this.pagamentos = [];
+      this.carregando = false;
+    },
+    async buscarPagamentos() {
+      try {
+        this.carregando = true;
+        const response = await $fetch(
+          "/api/front-api/pagamentos"
+        );
+        const pagamentosTraduzidos = traduzirPagamentos(response);
+        this.pagamentos = pagamentosTraduzidos.dados ?? [];
+        this.carregando = false;
+      } catch {
+        this.pagamentos = [];
+        this.carregando = false;
+      }
+    }
+  },
+  persist: {
+    storage: piniaPluginPersistedstate.sessionStorage()
+  }
+});

package/dist/runtime/stores/paginas.d.ts

@@ -0,0 +1,5 @@
+import type { StorefrontPaginaResponse } from 'godeep-types/types';
+export declare const storePaginas: import("pinia").StoreDefinition<"paginas", {
+    pagina: StorefrontPaginaResponse;
+    carregando: boolean;
+}, {}, {}>;

package/dist/runtime/stores/paginas.js

@@ -0,0 +1,35 @@
+import { traduzirPagina } from "godeep-types/translate";
+import { defineStore } from "pinia";
+export const storePaginas = defineStore("paginas", {
+  state: () => ({
+    pagina: {},
+    carregando: false
+  }),
+  getters: {
+    recuperarPagina: (state) => state.pagina,
+    paginasCarregando: (state) => state.carregando
+  },
+  actions: {
+    async resetarPagina() {
+      this.pagina = {};
+      this.carregando = false;
+    },
+    async buscarPaginas(slug) {
+      try {
+        this.carregando = true;
+        const response = await $fetch(
+          `/api/front-api/paginas?slug=${slug}`
+        );
+        const paginaTraduzida = traduzirPagina(response);
+        this.pagina = paginaTraduzida ?? {};
+        this.carregando = false;
+      } catch {
+        this.pagina = {};
+        this.carregando = false;
+      }
+    }
+  },
+  persist: {
+    storage: piniaPluginPersistedstate.sessionStorage()
+  }
+});

package/dist/runtime/stores/pedidos.d.ts

@@ -0,0 +1,7 @@
+import type { StorefrontPedidosResponse } from 'godeep-types/types';
+export declare const storePedidos: import("pinia").StoreDefinition<"pedidos", {
+    pedidos: StorefrontPedidosResponse["pedidos"];
+    paginador: StorefrontPedidosResponse["paginador"];
+    carregando: boolean;
+    erro: string;
+}, {}, {}>;

package/dist/runtime/stores/pedidos.js

@@ -0,0 +1,59 @@
+import { defineStore } from "pinia";
+import { alerta } from "../utils/alerta.js";
+import { traduzirPedidos } from "godeep-types/translate";
+export const storePedidos = defineStore("pedidos", {
+  state: () => ({
+    pedidos: [],
+    paginador: void 0,
+    carregando: false,
+    erro: ""
+  }),
+  getters: {
+    recuperarPedidos: (state) => state.pedidos,
+    recuperarPaginador: (state) => state.paginador,
+    pedidosCarregando: (state) => state.carregando,
+    pedidosErro: (state) => state.erro
+  },
+  actions: {
+    resetarPedidos() {
+      this.pedidos = [];
+      this.paginador = void 0;
+      this.carregando = false;
+      this.erro = "";
+    },
+    async buscarPedidos(token) {
+      this.carregando = true;
+      this.erro = "";
+      try {
+        if (!token) throw new Error("Token de autentica\xE7\xE3o n\xE3o encontrado");
+        const resposta = await $fetch(
+          "/api/front-api/pedidos",
+          {
+            method: "GET",
+            headers: { "X-ACCESS-TOKEN": token }
+          }
+        );
+        const traduzido = traduzirPedidos(resposta);
+        this.pedidos = traduzido.pedidos;
+        this.paginador = traduzido.paginador;
+        return { sucesso: true, pedidos: this.pedidos };
+      } catch (error) {
+        this.pedidos = [];
+        this.paginador = void 0;
+        this.erro = "N\xE3o foi poss\xEDvel carregar seus pedidos.";
+        alerta.adicionar({
+          titulo: "Erro ao carregar pedidos",
+          descricao: this.erro,
+          cor: "error",
+          variantes: ["dashed", "soft"]
+        });
+        return { sucesso: false, erro: error };
+      } finally {
+        this.carregando = false;
+      }
+    }
+  },
+  persist: {
+    storage: piniaPluginPersistedstate.sessionStorage()
+  }
+});

package/dist/runtime/stores/produto.d.ts

@@ -0,0 +1,9 @@
+import type { StorefrontProduto, StorefrontProdutosRelacionados, StorefrontMetodoPagamento } from 'godeep-types/types';
+export declare const storeProduto: import("pinia").StoreDefinition<"produto", {
+    produto: StorefrontProduto;
+    produtos: StorefrontProduto[];
+    relacionados: StorefrontProdutosRelacionados | null;
+    metodosPagamento: StorefrontMetodoPagamento[];
+    metodosErro: string;
+    carregando: boolean;
+}, {}, {}>;

package/dist/runtime/stores/produto.js

@@ -0,0 +1,141 @@
+import {
+  traduzirProduto,
+  traduzirAviseme,
+  traduzirProdutosRelacionados,
+  traduzirMetodosPagamento
+} from "godeep-types/translate";
+import { defineStore } from "pinia";
+import { alerta } from "../utils/alerta.js";
+export const storeProduto = defineStore("produto", {
+  state: () => ({
+    produto: {},
+    produtos: [],
+    relacionados: null,
+    metodosPagamento: [],
+    metodosErro: "",
+    carregando: false
+  }),
+  getters: {
+    recuperarProduto: (state) => state.produto,
+    recuperarTodosProdutos: (state) => state.produtos,
+    produtoCarregando: (state) => state.carregando,
+    todosProdutosCarregando: (state) => state.carregando,
+    recuperarRelacionados: (state) => state.relacionados,
+    recuperarMetodosPagamento: (state) => state.metodosPagamento,
+    recuperarMetodosErro: (state) => state.metodosErro
+  },
+  actions: {
+    async resetarProduto() {
+      this.produto = {};
+      this.produtos = [];
+      this.relacionados = null;
+      this.metodosPagamento = [];
+      this.metodosErro = "";
+      this.carregando = false;
+    },
+    async buscarProduto(slug) {
+      try {
+        this.carregando = true;
+        const response = await $fetch(
+          `/api/front-api/produtos/${slug}`
+        );
+        const produtoTraduzido = traduzirProduto(response);
+        this.produto = produtoTraduzido ?? {};
+        this.carregando = false;
+      } catch {
+        this.produto = {};
+        this.carregando = false;
+      }
+    },
+    async listarTodosProdutos() {
+      try {
+        this.carregando = true;
+        const response = await $fetch("/api/front-api/produtos");
+        const produtosTraduzidos = response.map(
+          (produto) => traduzirProduto(produto)
+        );
+        this.produtos = produtosTraduzidos ?? [];
+        this.carregando = false;
+      } catch {
+        this.produtos = [];
+        this.carregando = false;
+      }
+    },
+    async avisemeQuandoChegar(idProduto, email, nome) {
+      try {
+        this.carregando = true;
+        const response = await $fetch("/api/front-api/aviseme", {
+          method: "POST",
+          body: {
+            idProduto,
+            email,
+            nome
+          }
+        });
+        this.carregando = false;
+        return traduzirAviseme(response);
+      } catch {
+        this.carregando = false;
+        alerta.adicionar({
+          titulo: "Erro",
+          descricao: "Erro ao avisar quando chegar",
+          cor: "error",
+          variantes: ["dashed", "soft"]
+        });
+      }
+    },
+    async buscarProdutosRelacionados(idProduto) {
+      if (!idProduto || idProduto === 0) {
+        this.relacionados = null;
+        return;
+      }
+      try {
+        this.carregando = true;
+        const resposta = await $fetch(
+          `/api/front-api/produtosRelacionados/${idProduto}`
+        );
+        this.relacionados = traduzirProdutosRelacionados(resposta);
+      } catch {
+        this.relacionados = null;
+      } finally {
+        this.carregando = false;
+      }
+    },
+    async buscarMetodosPagamento(idProduto, quantidade, cep) {
+      if (!idProduto || idProduto === 0) {
+        this.metodosPagamento = [];
+        this.metodosErro = "Produto inv\xE1lido";
+        return;
+      }
+      try {
+        this.carregando = true;
+        this.metodosErro = "";
+        this.metodosPagamento = [];
+        const cepLimpo = cep?.replace(/\D/g, "");
+        const body = {
+          id: idProduto,
+          quantidade
+        };
+        if (cepLimpo && cepLimpo.length === 8) {
+          body.cep = cepLimpo;
+        }
+        const resposta = await $fetch(
+          "/api/front-api/payment-methods/product",
+          {
+            method: "POST",
+            body
+          }
+        );
+        this.metodosPagamento = traduzirMetodosPagamento(resposta);
+      } catch (error) {
+        this.metodosPagamento = [];
+        this.metodosErro = error?.data?.message ?? error?.message ?? "Erro ao buscar m\xE9todos de pagamento";
+      } finally {
+        this.carregando = false;
+      }
+    }
+  },
+  persist: {
+    storage: piniaPluginPersistedstate.sessionStorage()
+  }
+});

package/dist/runtime/stores/redes-sociais.d.ts

@@ -0,0 +1,5 @@
+import type { StorefrontRedeSocial } from 'godeep-types/types';
+export declare const storeRedesSociais: import("pinia").StoreDefinition<"redes-sociais", {
+    redes: StorefrontRedeSocial[];
+    carregando: boolean;
+}, {}, {}>;

package/dist/runtime/stores/redes-sociais.js

@@ -0,0 +1,38 @@
+import { traduzirRedesSociais } from "godeep-types/translate";
+import { defineStore } from "pinia";
+export const storeRedesSociais = defineStore("redes-sociais", {
+  state: () => ({
+    redes: [],
+    carregando: false
+  }),
+  getters: {
+    recuperarRedesSociais: (state) => state.redes,
+    redesSociaisCarregando: (state) => state.carregando,
+    temRedesSociais: (state) => state.redes.length > 0
+  },
+  actions: {
+    resetarRedesSociais() {
+      this.redes = [];
+      this.carregando = false;
+    },
+    async buscarRedesSociais() {
+      try {
+        this.carregando = true;
+        const resposta = await $fetch(
+          "/api/front-api/redessociais",
+          {
+            method: "GET"
+          }
+        );
+        this.redes = traduzirRedesSociais(resposta);
+      } catch {
+        this.redes = [];
+      } finally {
+        this.carregando = false;
+      }
+    }
+  },
+  persist: {
+    storage: piniaPluginPersistedstate.sessionStorage()
+  }
+});

package/dist/runtime/stores/vitrine.d.ts

@@ -0,0 +1,13 @@
+import type { StorefrontVitrineListagem } from 'godeep-types/types';
+type FiltrosSelecionados = Record<string, string[]>;
+export declare const storeVitrine: import("pinia").StoreDefinition<"vitrine", {
+    vitrine: StorefrontVitrineListagem;
+    vitrinesCache: Record<string, StorefrontVitrineListagem>;
+    carregando: boolean;
+    paginaAtual: number;
+    ordenacao: string;
+    filtrosAtivos: FiltrosSelecionados;
+    slugBase: string;
+    subvitrineAtiva: string;
+}, {}, {}>;
+export {};