OriusTecnologia/saas_app
6
0
Fork 0
Code Issues Pull requests Projects Releases 1 Packages Wiki Activity Actions

Merge remote-tracking branch 'origin/release(MVP/Sprint6)' into MVPTN-37

Browse source
This commit is contained in:
Keven Willian Pereira de Souza 2025-10-30 16:10:25 -03:00
commit 79f2092882
135 changed files with 3477 additions and 489 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

136
eslint.config.mjs
View file

@ -1,74 +1,70 @@
import js from "@eslint/js";
import reactPlugin from "eslint-plugin-react";
import reactHooks from "eslint-plugin-react-hooks";
import jsxA11y from "eslint-plugin-jsx-a11y";
import importPlugin from "eslint-plugin-import";
import tseslint from "typescript-eslint";
import js from '@eslint/js';
import reactPlugin from 'eslint-plugin-react';
import reactHooks from 'eslint-plugin-react-hooks';
import jsxA11y from 'eslint-plugin-jsx-a11y';
import importPlugin from 'eslint-plugin-import';
import tseslint from 'typescript-eslint';
export default [
js.configs.recommended,
...tseslint.configs.recommended,
{
files: ["**/*.ts", "**/*.tsx"],
ignores: ["node_modules/**", ".next/**", "out/**", "dist/**"],
languageOptions: {
ecmaVersion: "latest",
sourceType: "module",
parser: tseslint.parser,
parserOptions: {
project: "./tsconfig.json",
},
globals: {
React: true,
JSX: true,
},
},
plugins: {
react: reactPlugin,
"react-hooks": reactHooks,
"jsx-a11y": jsxA11y,
import: importPlugin,
},
settings: {
react: { version: "detect" },
"import/resolver": {
typescript: {
alwaysTryTypes: true,
project: "./tsconfig.json",
},
node: {
extensions: [".js", ".jsx", ".ts", ".tsx"],
},
},
},
rules: {
"react/react-in-jsx-scope": "off",
"react/jsx-uses-react": "off",
"react/jsx-uses-vars": "warn",
"react-hooks/rules-of-hooks": "error",
"react-hooks/exhaustive-deps": "warn",
"import/order": [
"error",
{
groups: [
["builtin", "external"],
["internal"],
["parent", "sibling", "index"],
],
pathGroups: [
{
pattern: "@/**",
group: "internal",
position: "after",
},
],
alphabetize: { order: "asc", caseInsensitive: true },
"newlines-between": "always",
},
],
"import/no-duplicates": "error",
"import/newline-after-import": ["error", { count: 1 }],
"no-unused-vars": "warn",
},
js.configs.recommended,
...tseslint.configs.recommended,
{
files: ['**/*.ts', '**/*.tsx'],
ignores: ['node_modules/**', '.next/**', 'out/**', 'dist/**'],
languageOptions: {
ecmaVersion: 'latest',
sourceType: 'module',
parser: tseslint.parser,
parserOptions: {
project: './tsconfig.json',
},
globals: {
React: true,
JSX: true,
},
},
plugins: {
react: reactPlugin,
'react-hooks': reactHooks,
'jsx-a11y': jsxA11y,
import: importPlugin,
},
settings: {
react: { version: 'detect' },
'import/resolver': {
typescript: {
alwaysTryTypes: true,
project: './tsconfig.json',
},
node: {
extensions: ['.js', '.jsx', '.ts', '.tsx'],
},
},
},
rules: {
'react/react-in-jsx-scope': 'off',
'react/jsx-uses-react': 'off',
'react/jsx-uses-vars': 'warn',
'react-hooks/rules-of-hooks': 'error',
'react-hooks/exhaustive-deps': 'warn',
'import/order': [
'error',
{
groups: [['builtin', 'external'], ['internal'], ['parent', 'sibling', 'index']],
pathGroups: [
{
pattern: '@/**',
group: 'internal',
position: 'after',
},
],
alphabetize: { order: 'asc', caseInsensitive: true },
'newlines-between': 'always',
},
],
'import/no-duplicates': 'error',
'import/newline-after-import': ['error', { count: 1 }],
'no-unused-vars': 'warn',
},
},
];

10
src/app/(protected)/(administrativo)/administrativo/andamentos/page.tsx
View file

@ -1,9 +1,5 @@
import TTBAndamentoServicoIndex from "@/packages/administrativo/components/TTBAndamentoServico/TTBAndamentoServicoIndex";
import TTBAndamentoServicoIndex from '@/packages/administrativo/components/TTBAndamentoServico/TTBAndamentoServicoIndex';
export default function TAtoParteTipo() {
return (
< TTBAndamentoServicoIndex />
);
}
return <TTBAndamentoServicoIndex />;
}

10
src/app/(protected)/(administrativo)/administrativo/atos/partes-tipos/page.tsx
View file

@ -1,9 +1,5 @@
import TAtoParteTipoIndex from "@/packages/administrativo/components/TAtoParteTipo/TAtoParteTipoIndex";
import TAtoParteTipoIndex from '@/packages/administrativo/components/TAtoParteTipo/TAtoParteTipoIndex';
export default function TAtoParteTipo() {
return (
< TAtoParteTipoIndex />
);
}
return <TAtoParteTipoIndex />;
}

6
src/app/(protected)/(administrativo)/administrativo/bairros/page.tsx
View file

@ -1,9 +1,7 @@
'use client';
import GTBBairroIndex from "@/packages/administrativo/components/GTBBairro/GTBBairroIndex";
import GTBBairroIndex from '@/packages/administrativo/components/GTBBairro/GTBBairroIndex';
export default function GCidadePage() {
return (
< GTBBairroIndex />
);
return <GTBBairroIndex />;
}

6
src/app/(protected)/(administrativo)/administrativo/censec/naturezas/page.tsx
View file

@ -1,9 +1,7 @@
'use client';
import TCensecTipoNaturezaIndex from "@/packages/administrativo/components/TCensecTipoNatureza/TCensecTipoNaturezaIndex";
import TCensecTipoNaturezaIndex from '@/packages/administrativo/components/TCensecTipoNatureza/TCensecTipoNaturezaIndex';
export default function TCensecTipoNaturezaPage() {
return (
< TCensecTipoNaturezaIndex />
);
return <TCensecTipoNaturezaIndex />;
}

6
src/app/(protected)/(administrativo)/administrativo/censec/qualidades/page.tsx
View file

@ -1,9 +1,7 @@
'use client';
import TCensecQualidadeIndex from "@/packages/administrativo/components/TCensecQualidade/TCensecQualidadeIndex";
import TCensecQualidadeIndex from '@/packages/administrativo/components/TCensecQualidade/TCensecQualidadeIndex';
export default function TCensecQualidadePage() {
return (
< TCensecQualidadeIndex />
);
return <TCensecQualidadeIndex />;
}

6
src/app/(protected)/(administrativo)/administrativo/centrais/censec/centrais/page.tsx
View file

@ -1,9 +1,7 @@
'use client';
import TCensecIndex from "@/packages/administrativo/components/TCensec/TCensecIndex";
import TCensecIndex from '@/packages/administrativo/components/TCensec/TCensecIndex';
export default function GTBEstadoCivilPage() {
return (
< TCensecIndex />
);
return <TCensecIndex />;
}

6
src/app/(protected)/(administrativo)/administrativo/centrais/censec/naturezas-litigios/page.tsx
View file

@ -1,9 +1,7 @@
'use client';
import TCensecNaturezaLitigioIndex from "@/packages/administrativo/components/TCensecNaturezaLitigio/TCensecNaturezaLitigioIndex";
import TCensecNaturezaLitigioIndex from '@/packages/administrativo/components/TCensecNaturezaLitigio/TCensecNaturezaLitigioIndex';
export default function GCidadePage() {
return (
< TCensecNaturezaLitigioIndex />
);
return <TCensecNaturezaLitigioIndex />;
}

6
src/app/(protected)/(administrativo)/administrativo/centrais/censec/qualidades/page.tsx
View file

@ -1,9 +1,7 @@
'use client';
import TCensecQualidadeIndex from "@/packages/administrativo/components/TCensecQualidade/TCensecQualidadeIndex";
import TCensecQualidadeIndex from '@/packages/administrativo/components/TCensecQualidade/TCensecQualidadeIndex';
export default function GTBEstadoCivilPage() {
return (
< TCensecQualidadeIndex />
);
return <TCensecQualidadeIndex />;
}

6
src/app/(protected)/(administrativo)/administrativo/centrais/censec/tipos-atos/page.tsx
View file

@ -1,9 +1,7 @@
'use client';
import TCensecTipoAtoIndex from "@/packages/administrativo/components/TCensecTipoAto/TCensecTipoAtoIndex";
import TCensecTipoAtoIndex from '@/packages/administrativo/components/TCensecTipoAto/TCensecTipoAtoIndex';
export default function GTBEstadoCivilPage() {
return (
< TCensecTipoAtoIndex />
);
return <TCensecTipoAtoIndex />;
}

6
src/app/(protected)/(administrativo)/administrativo/cidades/page.tsx
View file

@ -1,9 +1,7 @@
'use client';
import GCidadeIndex from "@/packages/administrativo/components/GCidade/GCidadeIndex";
import GCidadeIndex from '@/packages/administrativo/components/GCidade/GCidadeIndex';
export default function GCidadePage() {
return (
< GCidadeIndex />
);
return <GCidadeIndex />;
}

2
src/app/(protected)/(administrativo)/administrativo/imoveis/rurais/page.tsx
View file

@ -1,6 +1,6 @@
'use client';
import TImovelIndex from "@/packages/administrativo/components/TImovel/TImovelIndex";
import TImovelIndex from '@/packages/administrativo/components/TImovel/TImovelIndex';
export default function TImovelRuralPage() {
return (

6
src/app/(protected)/(administrativo)/administrativo/imoveis/tipos-logradouros/page.tsx
View file

@ -1,9 +1,7 @@
'use client';
import GTBTipoLogradouroIndex from "@/packages/administrativo/components/GTBTipoLogradouro/GTBTipoLogradouroIndex";
import GTBTipoLogradouroIndex from '@/packages/administrativo/components/GTBTipoLogradouro/GTBTipoLogradouroIndex';
export default function GMedidaTipoPage() {
return (
< GTBTipoLogradouroIndex />
);
return <GTBTipoLogradouroIndex />;
}

4
src/app/(protected)/(administrativo)/administrativo/imoveis/urbanos/page.tsx
View file

@ -1,6 +1,6 @@
'use client';
import TImovelIndex from "@/packages/administrativo/components/TImovel/TImovelIndex";
import TImovelIndex from '@/packages/administrativo/components/TImovel/TImovelIndex';
export default function TImovelUrbanoPage() {
return (
@ -10,4 +10,4 @@ export default function TImovelUrbanoPage() {
tipoClasse={1}
/>
);
}
}

6
src/app/(protected)/(administrativo)/administrativo/medidas/tipos/page.tsx
View file

@ -1,9 +1,7 @@
'use client';
import GMedidaTipoIndex from "@/packages/administrativo/components/GMedidaTipo/GMedidaTipoIndex";
import GMedidaTipoIndex from '@/packages/administrativo/components/GMedidaTipo/GMedidaTipoIndex';
export default function GMedidaTipoPage() {
return (
< GMedidaTipoIndex />
);
return <GMedidaTipoIndex />;
}

12
src/app/(protected)/(administrativo)/administrativo/minutas/naturezas/page.tsx
View file

@ -1,11 +1,5 @@
import GNaturezaIndex from "@/packages/administrativo/components/GNatureza/GNaturezaIndex";
import GNaturezaIndex from '@/packages/administrativo/components/GNatureza/GNaturezaIndex';
export default function GNaturezaPage() {
return (
<GNaturezaIndex
sistema_id={2}
/>
);
}
return <GNaturezaIndex sistema_id={2} />;
}

6
src/app/(protected)/(administrativo)/administrativo/pessoas/estados-civis/page.tsx
View file

@ -1,9 +1,7 @@
'use client';
import GTBEstadoCivilIndex from "@/packages/administrativo/components/GTBEstadoCivil/GTBEstadoCivilIndex";
import GTBEstadoCivilIndex from '@/packages/administrativo/components/GTBEstadoCivil/GTBEstadoCivilIndex';
export default function GTBEstadoCivilPage() {
return (
< GTBEstadoCivilIndex />
);
return <GTBEstadoCivilIndex />;
}

4
src/app/(protected)/(administrativo)/administrativo/pessoas/fisicas/page.tsx
View file

@ -3,7 +3,5 @@
import TPessoaFisicaIndex from '@/packages/administrativo/components/TPessoa/TPessoaFisica/TPessoaFisicaIndex';
export default function TPessoaFisica() {
return (
<TPessoaFisicaIndex />
);
return <TPessoaFisicaIndex />;
}

5
src/app/(protected)/(administrativo)/administrativo/pessoas/juridicas/page.tsx
View file

@ -3,8 +3,5 @@
import TPessoaJuridicaIndex from '@/packages/administrativo/components/TPessoa/TPessoaJuridica/TPessoaJuridicaIndex';
export default function TPessoaFisica() {
return (
<TPessoaJuridicaIndex />
);
return <TPessoaJuridicaIndex />;
}

6
src/app/(protected)/(administrativo)/administrativo/pessoas/profissoes/page.tsx
View file

@ -1,9 +1,7 @@
'use client';
import GTBProfissaoIndex from "@/packages/administrativo/components/GTBProfissao/GTBProfissaoIndex";
import GTBProfissaoIndex from '@/packages/administrativo/components/GTBProfissao/GTBProfissaoIndex';
export default function GTBEstadoCivilPage() {
return (
< GTBProfissaoIndex />
);
return <GTBProfissaoIndex />;
}

6
src/app/(protected)/(administrativo)/administrativo/pessoas/regimes-bens/page.tsx
View file

@ -1,9 +1,7 @@
'use client';
import GTBRegimeBensIndex from "@/packages/administrativo/components/GTBRegimeBens/GTBRegimeBensIndex";
import GTBRegimeBensIndex from '@/packages/administrativo/components/GTBRegimeBens/GTBRegimeBensIndex';
export default function GTBRegimeBensPage() {
return (
< GTBRegimeBensIndex />
);
return <GTBRegimeBensIndex />;
}

6
src/app/(protected)/(administrativo)/administrativo/pessoas/regimes-comunhao/page.tsx
View file

@ -1,9 +1,7 @@
'use client';
import GTBRegimeComunhaoIndex from "@/packages/administrativo/components/GTBRegimeComunhao/GTBRegimeComunhaoIndex";
import GTBRegimeComunhaoIndex from '@/packages/administrativo/components/GTBRegimeComunhao/GTBRegimeComunhaoIndex';
export default function GTBRegimeBensPage() {
return (
< GTBRegimeComunhaoIndex />
);
return <GTBRegimeComunhaoIndex />;
}

10
src/app/(protected)/(administrativo)/administrativo/reconhecimentos/page.tsx
View file

@ -1,9 +1,5 @@
import TTBReconhecimentoTipoIndex from "@/packages/administrativo/components/TTBReconhecimentoTipo/TTBReconhecimentoTipoIndex";
import TTBReconhecimentoTipoIndex from '@/packages/administrativo/components/TTBReconhecimentoTipo/TTBReconhecimentoTipoIndex';
export default function TAtoParteTipo() {
return (
< TTBReconhecimentoTipoIndex />
);
}
return <TTBReconhecimentoTipoIndex />;
}

195
src/app/(protected)/(cadastros)/cadastros/(t_servico_tipo)/servicos-tipo/page.tsx Normal file
View file

@ -0,0 +1,195 @@
'use client';
import { useEffect, useState, useCallback } from 'react';
import { Card, CardContent } from '@/components/ui/card';
import Loading from '@/shared/components/loading/loading';
// Componentes específicos para TServicoTipo
import TServicoTipoTable from '../../_components/t_servico_tipo/TServicoTipoTable';
import TServicoTipoForm from '../../_components/t_servico_tipo/TServicoTipoForm';
// Hooks específicos para TServicoTipo
import { useTServicoTipoReadHook } from '../../_hooks/t_servico_tipo/useTServicoTipoReadHook';
import { useTServicoTipoSaveHook } from '../../_hooks/t_servico_tipo/useTServicoTipoSaveHook';
import { useTServicoTipoRemoveHook } from '../../_hooks/t_servico_tipo/useTServicoTipoRemoveHook';
import { useTServicoTipoEditHook } from '../../_hooks/t_servico_tipo/useTServicoTipoEditHook';
import ConfirmDialog from '@/shared/components/confirmDialog/ConfirmDialog';
import { useConfirmDialog } from '@/shared/components/confirmDialog/useConfirmDialog';
// Interface específica para TServicoTipo
import TServicoTipoInterface from '../../_interfaces/TServicoTipoInterface';
import Header from '@/shared/components/structure/Header';
export default function TServicoTipoPage() {
// Hooks para leitura, salvamento e remoção
const { tServicoTipo, fetchTServicoTipo } = useTServicoTipoReadHook();
const { saveTServicoTipo } = useTServicoTipoSaveHook();
const { removeTServicoTipo } = useTServicoTipoRemoveHook();
const { editTServicoTipo } = useTServicoTipoEditHook();
// Estados
const [selectedServicoTipo, setSelectedServicoTipo] = useState<TServicoTipoInterface | null>(
null,
);
const [isFormOpen, setIsFormOpen] = useState(false);
// Estado para saber qual item será deletado
const [itemToDelete, setItemToDelete] = useState<TServicoTipoInterface | null>(null);
/**
* Hook do modal de confirmação
*/
const {
isOpen: isConfirmOpen,
openDialog: openConfirmDialog,
// handleConfirm, // Não usado diretamente aqui, mas pode ser útil em outros contextos
handleCancel,
} = useConfirmDialog();
/**
* Abre o formulário no modo de edição ou criação
*/
const handleOpenForm = useCallback(
async (data: TServicoTipoInterface | null) => {
// Fecha o formulário antes de reabrir (garante reset limpo)
setIsFormOpen(false);
// Se nenhum dado for passado, abre o formulário em modo de criação
if (!data) {
setSelectedServicoTipo(null);
setIsFormOpen(true);
return;
}
// Define o item selecionado para edição
setSelectedServicoTipo(data);
// Aguarda carregar/editar o registro (o hook espera o objeto TServicoTipoInterface)
await editTServicoTipo(data);
// Atualiza a lista de dados
await fetchTServicoTipo();
setIsFormOpen(true);
},
[editTServicoTipo, fetchTServicoTipo],
);
/**
* Fecha o formulário e limpa o item selecionado
*/
const handleCloseForm = useCallback((_: null, __: boolean) => {
setSelectedServicoTipo(null);
setIsFormOpen(false);
}, []);
/**
* Salva os dados do formulário
*/
const handleSave = useCallback(
async (formData: TServicoTipoInterface) => {
// Aguarda salvar o registro
await saveTServicoTipo(formData);
// Atualiza a lista de dados
fetchTServicoTipo();
},
[saveTServicoTipo, fetchTServicoTipo],
);
/**
* Quando o usuário clica em "remover" na tabela
*/
const handleConfirmDelete = useCallback(
(item: TServicoTipoInterface) => {
// Define o item atual para remoção
setItemToDelete(item);
// Abre o modal de confirmação
openConfirmDialog();
},
[openConfirmDialog],
);
/**
* Executa a exclusão de fato quando o usuário confirma
*/
const handleDelete = useCallback(async () => {
// Protege contra null
if (!itemToDelete) return;
// Executa o Hook de remoção
await removeTServicoTipo(itemToDelete);
// Atualiza a lista
await fetchTServicoTipo();
// Limpa o item selecionado
setItemToDelete(null);
// Fecha o modal
handleCancel();
}, [itemToDelete, removeTServicoTipo, fetchTServicoTipo, handleCancel]);
/**
* Busca inicial dos dados
*/
useEffect(() => {
fetchTServicoTipo();
}, []);
/**
* Tela de loading enquanto carrega os dados
*/
if (!tServicoTipo) {
return <Loading type={2} />;
}
return (
<div>
{/* Cabeçalho */}
<Header
title={'Tipos de Serviço'}
description={'Gerenciamento de Tipos de Serviço'}
buttonText={'Novo Tipo'}
buttonAction={() => {
handleOpenForm(null);
}}
/>
{/* Tabela de Tipos de Serviço */}
<Card>
<CardContent>
<TServicoTipoTable
data={tServicoTipo}
onEdit={handleOpenForm}
onDelete={handleConfirmDelete}
/>
</CardContent>
</Card>
{/* Modal de confirmação */}
<ConfirmDialog
isOpen={isConfirmOpen}
title="Confirmar exclusão"
description="Atenção"
// Adaptação da mensagem para a interface TServicoTipo
message={`Deseja realmente excluir o tipo de serviço "${itemToDelete?.descricao}"?`}
confirmText="Sim, excluir"
cancelText="Cancelar"
onConfirm={handleDelete}
onCancel={handleCancel}
/>
{/* Formulário de criação/edição */}
<TServicoTipoForm
isOpen={isFormOpen}
data={selectedServicoTipo}
onClose={handleCloseForm}
onSave={handleSave}
/>
</div>
);
}

1004
src/app/(protected)/(cadastros)/cadastros/_components/t_servico_tipo/TServicoTipoForm.tsx Normal file
View file

File diff suppressed because it is too large Load diff

101
src/app/(protected)/(cadastros)/cadastros/_components/t_servico_tipo/TServicoTipoTable.tsx Normal file
View file

@ -0,0 +1,101 @@
'use client';
import { Button } from '@/components/ui/button';
import {
DropdownMenu,
DropdownMenuContent,
DropdownMenuGroup,
DropdownMenuItem,
DropdownMenuSeparator,
DropdownMenuTrigger,
} from '@/components/ui/dropdown-menu';
import {
Table,
TableBody,
TableCell,
TableHead,
TableHeader,
TableRow,
} from '@/components/ui/table';
import { EllipsisIcon, PencilIcon, Trash2Icon } from 'lucide-react';
import TServicoTipoInterface from '../../_interfaces/TServicoTipoInterface'; // Import alterado
// Tipagem das props do componente da tabela
interface TServicoTipoTableProps {
// Nome da interface alterado
data: TServicoTipoInterface[]; // lista de tipos de serviço
onEdit: (item: TServicoTipoInterface, isEditingFormStatus: boolean) => void; // callback para edição
onDelete: (item: TServicoTipoInterface, isEditingFormStatus: boolean) => void; // callback para exclusão
}
/**
* Componente principal da tabela de Tipos de Serviço
*/
export default function TServicoTipoTable({ data, onEdit, onDelete }: TServicoTipoTableProps) {
return (
<Table className="w-full table-fixed">
{/* Cabeçalho da tabela */}
<TableHeader>
<TableRow>
<TableHead className="w-15 font-bold">#</TableHead>
{/* As colunas IBGE e UF foram removidas */}
<TableHead className="font-bold">Descrição</TableHead>
<TableHead className="text-right"></TableHead>
</TableRow>
</TableHeader>
{/* Corpo da tabela */}
<TableBody>
{data.map((item) => (
// Assumindo que o ID do Tipo de Serviço é 'servico_tipo_id'
<TableRow key={item.servico_tipo_id} className="cursor-pointer">
{/* ID do Tipo de Serviço */}
<TableCell>{item.servico_tipo_id}</TableCell>
{/* Nome/descrição do Tipo de Serviço (descricao) */}
<TableCell>{item.descricao}</TableCell>
{/* As células de IBGE e UF foram removidas */}
{/* Ações (menu dropdown) */}
<TableCell className="text-right">
<DropdownMenu>
{/* Botão de disparo do menu */}
<DropdownMenuTrigger asChild>
<Button variant="outline" size="icon" className="cursor-pointer">
<EllipsisIcon />
</Button>
</DropdownMenuTrigger>
{/* Conteúdo do menu */}
<DropdownMenuContent side="left" align="start">
<DropdownMenuGroup>
{/* Opção editar */}
<DropdownMenuItem
className="cursor-pointer"
onSelect={() => onEdit(item, true)}
>
<PencilIcon className="mr-2 h-4 w-4" />
Editar
</DropdownMenuItem>
<DropdownMenuSeparator />
{/* Opção remover */}
<DropdownMenuItem
className="cursor-pointer"
onSelect={() => onDelete(item, true)}
>
<Trash2Icon className="mr-2 h-4 w-4" />
Remover
</DropdownMenuItem>
</DropdownMenuGroup>
</DropdownMenuContent>
</DropdownMenu>
</TableCell>
</TableRow>
))}
</TableBody>
</Table>
);
}

27
src/app/(protected)/(cadastros)/cadastros/_data/CCaixaServico/CCaixaServicoIndexData.ts Normal file
View file

@ -0,0 +1,27 @@
// Importa o utilitário responsável por tratar erros de forma padronizada no cliente
import { withClientErrorHandler } from '@/shared/actions/withClientErrorHandler/withClientErrorHandler';
// Importa a classe de serviço que gerencia requisições HTTP para a API
import API from '@/shared/services/api/Api';
// Importa o enum que define os métodos HTTP disponíveis (GET, POST, PUT, DELETE, etc.)
import { Methods } from '@/shared/services/api/enums/ApiMethodEnum';
import { CCaixaServicoReadInterface } from '../../_interfaces/CCaixaServicoReadInterface';
// Função assíncrona responsável por executar a requisição para listar os tipos de marcação
async function executeCCaixaServicoIndexData(data: CCaixaServicoReadInterface) {
// Cria uma nova instância da classe API para enviar a requisição
const api = new API();
// Concatena o endpoint com a query string (caso existam parâmetros)
const endpoint = `administrativo/c_caixa_servico/sistema/${data.sistema_id}`;
// Envia uma requisição GET para o endpoint 'administrativo/g_marcacao_tipo/'
return await api.send({
method: Methods.GET,
endpoint: endpoint,
});
}
// Exporta a função encapsulada pelo handler de erro, garantindo tratamento uniforme em caso de falhas
export const CCaixaServicoIndexData = withClientErrorHandler(executeCCaixaServicoIndexData);

27
src/app/(protected)/(cadastros)/cadastros/_data/GEmolumento/GEmolumentoIndexData.ts Normal file
View file

@ -0,0 +1,27 @@
// Importa o utilitário responsável por tratar erros de forma padronizada no cliente
import { withClientErrorHandler } from '@/shared/actions/withClientErrorHandler/withClientErrorHandler';
// Importa a classe de serviço que gerencia requisições HTTP para a API
import API from '@/shared/services/api/Api';
// Importa o enum que define os métodos HTTP disponíveis (GET, POST, PUT, DELETE, etc.)
import { Methods } from '@/shared/services/api/enums/ApiMethodEnum';
import { GEmolumentoReadInterface } from '../../_interfaces/GEmolumentoReadInterface';
// Função assíncrona responsável por executar a requisição para listar os tipos de marcação
async function executeGEmolumentoIndexData(data: GEmolumentoReadInterface) {
// Cria uma nova instância da classe API para enviar a requisição
const api = new API();
// Concatena o endpoint com a query string (caso existam parâmetros)
const endpoint = `administrativo/g_emolumento/${data.sistema_id}`;
// Envia uma requisição GET para o endpoint 'administrativo/g_marcacao_tipo/'
return await api.send({
method: Methods.GET,
endpoint: endpoint,
});
}
// Exporta a função encapsulada pelo handler de erro, garantindo tratamento uniforme em caso de falhas
export const GEmolumentoIndexData = withClientErrorHandler(executeGEmolumentoIndexData);

27
src/app/(protected)/(cadastros)/cadastros/_data/GEmolumentoItem/GEmolumentoItemValorData.ts Normal file
View file

@ -0,0 +1,27 @@
// Importa o utilitário responsável por tratar erros de forma padronizada no cliente
import { withClientErrorHandler } from '@/shared/actions/withClientErrorHandler/withClientErrorHandler';
// Importa a classe de serviço que gerencia requisições HTTP para a API
import API from '@/shared/services/api/Api';
// Importa o enum que define os métodos HTTP disponíveis (GET, POST, PUT, DELETE, etc.)
import { Methods } from '@/shared/services/api/enums/ApiMethodEnum';
import { GEmolumentoItemReadInterface } from '../../_interfaces/GEmolumentoItemReadInterface';
// Função assíncrona responsável por executar a requisição para listar os tipos de marcação
async function executeGEmolumentoItemValorData(data: GEmolumentoItemReadInterface) {
// Cria uma nova instância da classe API para enviar a requisição
const api = new API();
// Concatena o endpoint com a query string (caso existam parâmetros)
const endpoint = `administrativo/g_emolumento_item/faixa/${data.emolumento_id}/${data.valor}`;
// Envia uma requisição GET para o endpoint 'administrativo/g_marcacao_tipo/'
return await api.send({
method: Methods.GET,
endpoint: endpoint,
});
}
// Exporta a função encapsulada pelo handler de erro, garantindo tratamento uniforme em caso de falhas
export const GEmolumentoItemValorData = withClientErrorHandler(executeGEmolumentoItemValorData);

33
src/app/(protected)/(cadastros)/cadastros/_data/GMarcacaoTipo/GMarcacaoTipoIndexData.ts Normal file
View file

@ -0,0 +1,33 @@
// Importa o utilitário responsável por tratar erros de forma padronizada no cliente
import { withClientErrorHandler } from '@/shared/actions/withClientErrorHandler/withClientErrorHandler';
// Importa a classe de serviço que gerencia requisições HTTP para a API
import API from '@/shared/services/api/Api';
// Importa o enum que define os métodos HTTP disponíveis (GET, POST, PUT, DELETE, etc.)
import { Methods } from '@/shared/services/api/enums/ApiMethodEnum';
import { GMarcacaoTipoReadInterface } from '../../_interfaces/GMarcacaoTipoReadInterface';
// Importa a função genérica que monta a query string dinamicamente
import { buildQueryString } from '@/shared/actions/api/buildQueryString';
// Função assíncrona responsável por executar a requisição para listar os tipos de marcação
async function executeGMarcacaoTipoIndexData(data: GMarcacaoTipoReadInterface) {
// Cria uma nova instância da classe API para enviar a requisição
const api = new API();
// Monta a query string reutilizando a função genérica
const queryString = buildQueryString(data);
// Concatena o endpoint com a query string (caso existam parâmetros)
const endpoint = `administrativo/g_marcacao_tipo/grupo${queryString}`;
// Envia uma requisição GET para o endpoint 'administrativo/g_marcacao_tipo/'
return await api.send({
method: Methods.GET,
endpoint: endpoint,
});
}
// Exporta a função encapsulada pelo handler de erro, garantindo tratamento uniforme em caso de falhas
export const GMarcacaoTipoIndexData = withClientErrorHandler(executeGMarcacaoTipoIndexData);

26
src/app/(protected)/(cadastros)/cadastros/_data/TServicoEtiqueta/TServicoEtiquetaReadData.ts Normal file
View file

@ -0,0 +1,26 @@
// Importa o serviço de API que será utilizado para realizar requisições HTTP
import API from '@/shared/services/api/Api'; //
// Importa o enum que contém os métodos HTTP disponíveis (GET, POST, PUT, DELETE)
import { Methods } from '@/shared/services/api/enums/ApiMethodEnum'; //
// Importa a interface tipada que define a estrutura dos dados do tipo de serviço
import { TServicoEtiquetaInterface } from '../../_interfaces/TServicoEtiquetaInterface';
// Importa função que encapsula chamadas assíncronas e trata erros automaticamente
import { withClientErrorHandler } from '@/shared/actions/withClientErrorHandler/withClientErrorHandler'; //
// Função assíncrona que implementa a lógica de localizar um tipo de serviço
async function executeTServicoEtiquetaService(data: TServicoEtiquetaInterface) {
// Instancia o cliente da API para enviar a requisição
const api = new API(); //
// Executa a requisição para a API com o método apropriado e envia o ID no endpoint
return await api.send({
method: Methods.GET, // Verbo GET para consulta
endpoint: `administrativo/t_servico_etiqueta/servico_tipo/${data.servico_tipo_id}`, // Endpoint e ID alterados
});
}
// Exporta a função de Readr tipo de serviço já encapsulada com tratamento de erros
export const TServicoEtiquetaReadData = withClientErrorHandler(executeTServicoEtiquetaService); // Nome da exportação alterado

28
src/app/(protected)/(cadastros)/cadastros/_data/TServicoEtiqueta/TServicoEtiquetaRemoveData.ts Normal file
View file

@ -0,0 +1,28 @@
// Importa o serviço de API que será utilizado para realizar requisições HTTP
import API from '@/shared/services/api/Api'; //
// Importa o enum que contém os métodos HTTP disponíveis (GET, POST, PUT, DELETE)
import { Methods } from '@/shared/services/api/enums/ApiMethodEnum'; //
// Importa a interface tipada que define a estrutura dos dados do tipo de serviço
import { TServicoEtiquetaInterface } from '../../_interfaces/TServicoEtiquetaInterface'; // Alterado de GCidadeInterface
// Importa função que encapsula chamadas assíncronas e trata erros automaticamente
import { withClientErrorHandler } from '@/shared/actions/withClientErrorHandler/withClientErrorHandler'; //
// Função assíncrona que implementa a lógica de remover um tipo de serviço
async function executeTServicoEtiquetaRemoveData(data: TServicoEtiquetaInterface) {
// Nome da função alterado
// Instancia o cliente da API para enviar a requisição
const api = new API(); //
// Executa a requisição para a API com o método apropriado e envia o ID no endpoint
return await api.send({
method: Methods.DELETE, // Verbo DELETE para exclusão
endpoint: `administrativo/t_servico_etiqueta/${data.servico_etiqueta_id}`, // Endpoint e ID alterados
});
}
// Exporta a função de remover tipo de serviço já encapsulada com tratamento de erros
export const TServicoEtiquetaRemoveData = withClientErrorHandler(executeTServicoEtiquetaRemoveData); // Nome da exportação alterado

35
src/app/(protected)/(cadastros)/cadastros/_data/TServicoEtiqueta/TServicoEtiquetaSaveData.ts Normal file
View file

@ -0,0 +1,35 @@
// Importa o serviço de API que será utilizado para realizar requisições HTTP
import API from '@/shared/services/api/Api'; //
// Importa o esquema de validação de dados para tipos de serviço
import { TServicoEtiquetaFormValues } from '../../_schemas/TServicoEtiquetaSchema';
// Importa o enum que contém os métodos HTTP disponíveis (GET, POST, PUT, DELETE)
import { Methods } from '@/shared/services/api/enums/ApiMethodEnum'; //
// Importa a interface tipada que define a estrutura dos dados do tipo de serviço
import { TServicoEtiquetaInterface } from '../../_interfaces/TServicoEtiquetaInterface'; // Interface alterada
// Importa função que encapsula chamadas assíncronas e trata erros automaticamente
import { withClientErrorHandler } from '@/shared/actions/withClientErrorHandler/withClientErrorHandler'; //
// Função assíncrona que implementa a lógica de salvar (criar/atualizar) um tipo de serviço
async function executeTServicoEtiquetaSaveData(data: TServicoEtiquetaFormValues) {
try {
// Instancia o cliente da API para enviar a requisição
const api = new API(); //
// Executa a requisição para a API com o método apropriado e envia os dados no corpo
return await api.send({
method: Methods.POST, // PUT se atualizar, POST se criar
endpoint: `administrativo/t_servico_etiqueta`, // Endpoint e ID alterados
body: data, // payload enviado para a API
});
} catch (error) {
console.error('Erro no TServicoEtiquetaSaveData:', error);
throw error; // propaga erro para o form
}
}
// Exporta a função de salvar tipo de serviço já encapsulada com tratamento de erros
export const TServicoEtiquetaSaveData = withClientErrorHandler(executeTServicoEtiquetaSaveData); // Nome da exportação alterado

26
src/app/(protected)/(cadastros)/cadastros/_data/TServicoTipo/TServicoTipoEditData.ts Normal file
View file

@ -0,0 +1,26 @@
// Importa o serviço de API que será utilizado para realizar requisições HTTP
import API from '@/shared/services/api/Api'; //
// Importa o enum que contém os métodos HTTP disponíveis (GET, POST, PUT, DELETE)
import { Methods } from '@/shared/services/api/enums/ApiMethodEnum'; //
// Importa a interface tipada que define a estrutura dos dados do tipo de serviço
import TServicoTipoInterface from '../../_interfaces/TServicoTipoInterface'; // Alterado de GCidadeInterface
// Importa função que encapsula chamadas assíncronas e trata erros automaticamente
import { withClientErrorHandler } from '@/shared/actions/withClientErrorHandler/withClientErrorHandler'; //
// Função assíncrona que implementa a lógica de localizar um tipo de serviço
async function executeTServicoTipoEditService(data: TServicoTipoInterface) {
// Instancia o cliente da API para enviar a requisição
const api = new API(); //
// Executa a requisição para a API com o método apropriado e envia o ID no endpoint
return await api.send({
method: Methods.GET, // Verbo GET para consulta
endpoint: `administrativo/t_servico_tipo/${data.servico_tipo_id}`, // Endpoint e ID alterados
});
}
// Exporta a função de Readr tipo de serviço já encapsulada com tratamento de erros
export const TServicoTipoEditData = withClientErrorHandler(executeTServicoTipoEditService); // Nome da exportação alterado

23
src/app/(protected)/(cadastros)/cadastros/_data/TServicoTipo/TServicoTipoIndexData.ts Normal file
View file

@ -0,0 +1,23 @@
// Importa o serviço de API que será utilizado para realizar requisições HTTP
import API from '@/shared/services/api/Api'; //
// Importa o enum que contém os métodos HTTP disponíveis (GET, POST, PUT, DELETE)
import { Methods } from '@/shared/services/api/enums/ApiMethodEnum'; //
// Importa função que encapsula chamadas assíncronas e trata erros automaticamente
import { withClientErrorHandler } from '@/shared/actions/withClientErrorHandler/withClientErrorHandler'; //
// Função assíncrona que implementa a lógica de buscar todos os tipos de serviço (GET)
async function executeTServicoTipoIndexData() {
// Instancia o cliente da API para enviar a requisição
const api = new API(); //
// Executa a requisição para a API com o método apropriado e o endpoint da tabela t_servico_tipo
return await api.send({
method: Methods.GET, // GET listar todos os itens
endpoint: `administrativo/t_servico_tipo/`, // Endpoint atualizado
});
}
// Exporta a função de listar tipos de serviço já encapsulada com tratamento de erros
export const TServicoTipoIndexData = withClientErrorHandler(executeTServicoTipoIndexData);

28
src/app/(protected)/(cadastros)/cadastros/_data/TServicoTipo/TServicoTipoRemoveData.ts Normal file
View file

@ -0,0 +1,28 @@
// Importa o serviço de API que será utilizado para realizar requisições HTTP
import API from '@/shared/services/api/Api'; //
// Importa o enum que contém os métodos HTTP disponíveis (GET, POST, PUT, DELETE)
import { Methods } from '@/shared/services/api/enums/ApiMethodEnum'; //
// Importa a interface tipada que define a estrutura dos dados do tipo de serviço
import TServicoTipoInterface from '../../_interfaces/TServicoTipoInterface'; // Alterado de GCidadeInterface
// Importa função que encapsula chamadas assíncronas e trata erros automaticamente
import { withClientErrorHandler } from '@/shared/actions/withClientErrorHandler/withClientErrorHandler'; //
// Função assíncrona que implementa a lógica de remover um tipo de serviço
async function executeTServicoTipoRemoveData(data: TServicoTipoInterface) {
// Nome da função alterado
// Instancia o cliente da API para enviar a requisição
const api = new API(); //
// Executa a requisição para a API com o método apropriado e envia o ID no endpoint
return await api.send({
method: Methods.DELETE, // Verbo DELETE para exclusão
endpoint: `administrativo/t_servico_tipo/${data.servico_tipo_id}`, // Endpoint e ID alterados
});
}
// Exporta a função de remover tipo de serviço já encapsulada com tratamento de erros
export const TServicoTipoRemoveData = withClientErrorHandler(executeTServicoTipoRemoveData); // Nome da exportação alterado

45
src/app/(protected)/(cadastros)/cadastros/_data/TServicoTipo/TServicoTipoSaveData.ts Normal file
View file

@ -0,0 +1,45 @@
// Importa o serviço de API que será utilizado para realizar requisições HTTP
import API from '@/shared/services/api/Api'; //
// Importa o esquema de validação de dados para tipos de serviço
import { TServicoTipoFormValues } from '../../_schemas/TServicoTipoSchema';
// Importa o enum que contém os métodos HTTP disponíveis (GET, POST, PUT, DELETE)
import { Methods } from '@/shared/services/api/enums/ApiMethodEnum'; //
// Importa a interface tipada que define a estrutura dos dados do tipo de serviço
import TServicoTipoInterface from '../../_interfaces/TServicoTipoInterface'; // Interface alterada
// Importa função que encapsula chamadas assíncronas e trata erros automaticamente
import { withClientErrorHandler } from '@/shared/actions/withClientErrorHandler/withClientErrorHandler'; //
// Função assíncrona que implementa a lógica de salvar (criar/atualizar) um tipo de serviço
async function executeTServicoTipoSaveData(
data: TServicoTipoFormValues & { metodo?: 'POST' | 'PUT' },
) {
// Verifica se existe ID do tipo de serviço para decidir se é atualização (PUT) ou criação (POST)
const isEditing = !!data.servico_tipo_id && Number(data.servico_tipo_id) > 0;
// Define método: prioridade para valor passado manualmente (metodo)
const method = data.metodo ?? (isEditing ? 'PUT' : 'POST');
try {
console.log(data);
// Instancia o cliente da API para enviar a requisição
const api = new API(); //
// Executa a requisição para a API com o método apropriado e envia os dados no corpo
return await api.send({
method: isEditing ? Methods.PUT : Methods.POST, // PUT se atualizar, POST se criar
endpoint: `administrativo/t_servico_tipo/${data.servico_tipo_id || ''}`, // Endpoint e ID alterados
body: data, // payload enviado para a API
});
} catch (error) {
console.error('Erro no TServicoTipoSaveData:', error);
throw error; // propaga erro para o form
}
}
// Exporta a função de salvar tipo de serviço já encapsulada com tratamento de erros
export const TServicoTipoSaveData = withClientErrorHandler(executeTServicoTipoSaveData); // Nome da exportação alterado

29
src/app/(protected)/(cadastros)/cadastros/_data/TTBReconhecimentoTipo/TTBReconhecimentoTipoIndexData.ts Normal file
View file

@ -0,0 +1,29 @@
// Importa o utilitário responsável por tratar erros de forma padronizada no cliente
import { withClientErrorHandler } from '@/shared/actions/withClientErrorHandler/withClientErrorHandler';
// Importa a classe de serviço que gerencia requisições HTTP para a API
import API from '@/shared/services/api/Api';
// Importa o enum que define os métodos HTTP disponíveis (GET, POST, PUT, DELETE, etc.)
import { Methods } from '@/shared/services/api/enums/ApiMethodEnum';
import { TTBReconhecimentoTipoReadInterface } from '../../_interfaces/TTBReconhecimentoTipoReadInterface';
// Função assíncrona responsável por executar a requisição para listar os tipos de marcação
async function executeTTBReconhecimentoTipoIndexData(data: TTBReconhecimentoTipoReadInterface) {
// Cria uma nova instância da classe API para enviar a requisição
const api = new API();
// Concatena o endpoint com a query string (caso existam parâmetros)
const endpoint = `administrativo/t_tb_reconhecimentotipo/`;
// Envia uma requisição GET para o endpoint 'administrativo/g_marcacao_tipo/'
return await api.send({
method: Methods.GET,
endpoint: endpoint,
});
}
// Exporta a função encapsulada pelo handler de erro, garantindo tratamento uniforme em caso de falhas
export const TTBReconhecimentoTipoIndexData = withClientErrorHandler(
executeTTBReconhecimentoTipoIndexData,
);

39
src/app/(protected)/(cadastros)/cadastros/_hooks/c_caixa_servico/useCCaixaServicoReadHook.ts Normal file
View file

@ -0,0 +1,39 @@
// Importa o hook responsável por gerenciar e exibir respostas globais (sucesso, erro, etc.)
import { useResponse } from '@/shared/components/response/ResponseContext';
// Importa hooks do React para gerenciamento de estado e memorização de valores
import { useMemo, useState } from 'react';
// Importa a interface que define a estrutura dos dados de "CCaixaServico"
import { CCaixaServicoReadInterface } from '../../_interfaces/CCaixaServicoReadInterface';
// Importa o serviço responsável por buscar os dados de "CCaixaServico" na API
import { CCaixaServicoIndexService } from '../../_services/c_caixa_servico/CCaixaServicoIndexService';
import { CCaixaServicoInterface } from '../../_interfaces/CCaixaServicoInterface';
// Hook personalizado para leitura (consulta) dos tipos de marcação
export const useCCaixaServicoReadHook = () => {
// Obtém a função que atualiza a resposta global do sistema
const { setResponse } = useResponse();
// Define o estado local que armazenará a lista de tipos de marcação
const [cCaixaServico, setCCaixaServico] = useState<CCaixaServicoInterface[]>([]);
// Função responsável por buscar os dados da API e atualizar o estado
const fetchCCaixaServico = async (data: CCaixaServicoReadInterface) => {
// Executa o serviço que faz a requisição à API
const response = await CCaixaServicoIndexService(data);
// Atualiza o estado local com os dados retornados
setCCaixaServico(response.data);
// Atualiza o contexto global de resposta (ex: para exibir alertas ou mensagens)
setResponse(response);
};
// Retorna os dados e a função de busca, memorizando o valor para evitar recriações desnecessárias
return useMemo(
() => ({ cCaixaServico, fetchCCaixaServico }),
[cCaixaServico, fetchCCaixaServico],
);
};

36
src/app/(protected)/(cadastros)/cadastros/_hooks/g_emolumento/useGEmolumentoReadHook.ts Normal file
View file

@ -0,0 +1,36 @@
// Importa o hook responsável por gerenciar e exibir respostas globais (sucesso, erro, etc.)
import { useResponse } from '@/shared/components/response/ResponseContext';
// Importa hooks do React para gerenciamento de estado e memorização de valores
import { useMemo, useState } from 'react';
// Importa a interface que define a estrutura dos dados de "GEmolumento"
import { GEmolumentoReadInterface } from '../../_interfaces/GEmolumentoReadInterface';
// Importa o serviço responsável por buscar os dados de "GEmolumento" na API
import { GEmolumentoIndexService } from '../../_services/g_emolumento/GEmolumentoIndexService';
import { GEmolumentoInterface } from '../../_interfaces/GEmolumentoInterface';
// Hook personalizado para leitura (consulta) dos emolumentos
export const useGEmolumentoReadHook = () => {
// Obtém a função que atualiza a resposta global do sistema
const { setResponse } = useResponse();
// Define o estado local que armazenará a lista de emolumentos
const [gEmolumento, setGEmolumento] = useState<GEmolumentoInterface[]>([]);
// Função responsável por buscar os dados da API e atualizar o estado
const fetchGEmolumento = async (data: GEmolumentoReadInterface) => {
// Executa o serviço que faz a requisição à API
const response = await GEmolumentoIndexService(data);
// Atualiza o estado local com os dados retornados
setGEmolumento(response.data);
// Atualiza o contexto global de resposta (ex: para exibir alertas ou mensagens)
setResponse(response);
};
// Retorna os dados e a função de busca, memorizando o valor para evitar recriações desnecessárias
return useMemo(() => ({ gEmolumento, fetchGEmolumento }), [gEmolumento, fetchGEmolumento]);
};

41
src/app/(protected)/(cadastros)/cadastros/_hooks/g_emolumento_item/useGEmolumentoItemReadHook.ts Normal file
View file

@ -0,0 +1,41 @@
// Importa o hook responsável por gerenciar e exibir respostas globais (sucesso, erro, etc.)
import { useResponse } from '@/shared/components/response/ResponseContext';
// Importa hooks do React para gerenciamento de estado e memorização de valores
import { useMemo, useState } from 'react';
// Importa a interface que define a estrutura dos dados de "gEmolumentoItem"
import { GEmolumentoItemReadInterface } from '../../_interfaces/GEmolumentoItemReadInterface';
// Importa o serviço responsável por buscar os dados de "GEmolumentoItem" na API
import { GEmolumentoItemValorService } from '../../_services/g_emolumento_item/GEmolumentoItemValorService';
import { GEmolumentoItemInterface } from '../../_interfaces/GEmolumentoItemInterface';
// Hook personalizado para leitura (consulta) dos emolumentos
export const useGEmolumentoItemReadHook = () => {
const { setResponse } = useResponse();
const [gGEmolumentoItem, setGEmolumentoItem] = useState<GEmolumentoItemInterface[]>([]);
const fetchGEmolumentoItem = async (data: GEmolumentoItemReadInterface) => {
try {
const response = await GEmolumentoItemValorService(data);
// Atualiza estado e contexto
setGEmolumentoItem(response.data);
setResponse(response);
// Retorna a resposta completa (para uso externo)
return response;
} catch (error) {
console.error('Erro ao buscar item de emolumento:', error);
setResponse({
message: 'Erro ao buscar item de emolumento',
error: error instanceof Error ? error.message : String(error),
});
return null; // Retorna nulo para segurança
}
};
// Retorna função e dados memorizados
return useMemo(() => ({ gGEmolumentoItem, fetchGEmolumentoItem }), [gGEmolumentoItem]);
};

39
src/app/(protected)/(cadastros)/cadastros/_hooks/g_marcacao_tipo/useGMarcacaoTipoReadHook.ts Normal file
View file

@ -0,0 +1,39 @@
// Importa o hook responsável por gerenciar e exibir respostas globais (sucesso, erro, etc.)
import { useResponse } from '@/shared/components/response/ResponseContext';
// Importa hooks do React para gerenciamento de estado e memorização de valores
import { useMemo, useState } from 'react';
// Importa a interface que define a estrutura dos dados de "GMarcacaoTipo"
import { GMarcacaoTipoReadInterface } from '../../_interfaces/GMarcacaoTipoReadInterface';
import { GMarcacaoTipoInterface } from '../../_interfaces/GMarcacaoTipoInterface';
// Importa o serviço responsável por buscar os dados de "GMarcacaoTipo" na API
import { GMarcacaoTipoIndexService } from '../../_services/g_marcacao_tipo/GMarcacaoTipoIndexService';
// Hook personalizado para leitura (consulta) dos tipos de marcação
export const useGMarcacaoTipoReadHook = () => {
// Obtém a função que atualiza a resposta global do sistema
const { setResponse } = useResponse();
// Define o estado local que armazenará a lista de tipos de marcação
const [gMarcacaoTipo, setGMarcacaoTipo] = useState<GMarcacaoTipoInterface[]>([]);
// Função responsável por buscar os dados da API e atualizar o estado
const fetchGMarcacaoTipo = async (data: GMarcacaoTipoReadInterface) => {
// Executa o serviço que faz a requisição à API
const response = await GMarcacaoTipoIndexService(data);
// Atualiza o estado local com os dados retornados
setGMarcacaoTipo(response.data);
// Atualiza o contexto global de resposta (ex: para exibir alertas ou mensagens)
setResponse(response);
};
// Retorna os dados e a função de busca, memorizando o valor para evitar recriações desnecessárias
return useMemo(
() => ({ gMarcacaoTipo, fetchGMarcacaoTipo }),
[gMarcacaoTipo, fetchGMarcacaoTipo],
);
};

43
src/app/(protected)/(cadastros)/cadastros/_hooks/t_servico_etiqueta/useTServicoEtiquetaReadHook.ts Normal file
View file

@ -0,0 +1,43 @@
// Importa o hook responsável por gerenciar e exibir respostas globais (sucesso, erro, etc.)
import { useResponse } from '@/shared/components/response/ResponseContext';
// Importa hooks do React para gerenciamento de estado e memorização de valores
import { useCallback, useState } from 'react';
// Importa a interface que define a estrutura dos dados de "TServicoEtiqueta"
import { TServicoEtiquetaInterface } from '../../_interfaces/TServicoEtiquetaInterface';
// Importa o serviço responsável por buscar os dados de "TServicoEtiqueta" na API
import { TServicoEtiquetaServicoIdService } from '../../_services/t_servico_etiqueta/TServicoEtiquetaServicoIdService';
// Hook personalizado para leitura (consulta) dos tipos de marcação
export const useTServicoEtiquetaReadHook = () => {
// Obtém a função que atualiza a resposta global do sistema
const { setResponse } = useResponse();
// Define o estado local que armazenará a lista de tipos de marcação
const [tServicoEtiqueta, setTServicoEtiqueta] = useState<TServicoEtiquetaInterface[]>([]);
// Função responsável por buscar os dados da API e atualizar o estado
const fetchTServicoEtiqueta = useCallback(
async (data: TServicoEtiquetaInterface) => {
try {
// Executa o serviço que faz a requisição à API
const response = await TServicoEtiquetaServicoIdService(data);
// Atualiza o estado local com os dados retornados
setTServicoEtiqueta(response.data);
// Atualiza o contexto global de resposta (ex: para exibir alertas ou mensagens)
setResponse(response);
} catch (error) {
console.error('Erro ao buscar etiquetas:', error);
return { data: [] };
}
},
[setResponse],
);
// Retorna os dados e a função de busca, memorizando o valor para evitar recriações desnecessárias
return { tServicoEtiqueta, fetchTServicoEtiqueta };
};

25
src/app/(protected)/(cadastros)/cadastros/_hooks/t_servico_etiqueta/useTServicoEtiquetaRemoveHook.ts Normal file
View file

@ -0,0 +1,25 @@
import { useResponse } from '@/shared/components/response/ResponseContext'; // Contexto global para gerenciar respostas da API
// Interface tipada do tipo de serviço
import { TServicoEtiquetaInterface } from '../../_interfaces/TServicoEtiquetaInterface';
// Função que remove o tipo de serviço via API
import { TServicoEtiquetaRemoveData } from '../../_data/TServicoEtiqueta/TServicoEtiquetaRemoveData';
// Hook customizado para remoção de tipos de serviço
export const useTServicoEtiquetaRemoveHook = () => {
// Hook do contexto de resposta para feedback global (alertas, mensagens etc.)
const { setResponse } = useResponse();
// Função assíncrona que remove um tipo de serviço
const fetchTServicoEtiquetaRemove = async (data: TServicoEtiquetaInterface) => {
// Chama a função de remoção passando os dados do tipo de serviço
const response = await TServicoEtiquetaRemoveData(data);
// Atualiza o contexto global com a resposta da API
setResponse(response);
};
// Retorna a função de remoção para ser usada no componente
return { fetchTServicoEtiquetaRemove };
};

37
src/app/(protected)/(cadastros)/cadastros/_hooks/t_servico_etiqueta/useTServicoEtiquetaSaveHook.ts Normal file
View file

@ -0,0 +1,37 @@
import { useState } from 'react';
import { useResponse } from '@/shared/components/response/ResponseContext';
// Interface tipada do serviço etiqueta
import { TServicoEtiquetaInterface } from '../../_interfaces/TServicoEtiquetaInterface';
// Serviço que salva os dados do serviço etiqueta
import { TServicoEtiquetaSaveService } from '../../_services/t_servico_etiqueta/TServicoEtiquetaSaveService';
export const useTServicoEtiquetaSaveHook = () => {
const { setResponse } = useResponse();
// Estado local para armazenar os dados do serviço etiqueta salvos
const [tServicoEtiquetaSave, setTServicoEtiquetaSave] =
useState<TServicoEtiquetaInterface | null>(null);
/**
* Função que executa o salvamento de um serviço etiqueta.
* @param data Os dados do serviço etiqueta a serem salvos.
*/
const fetchTServicoEtiquetaSave = async (data: TServicoEtiquetaInterface) => {
// Chama o serviço de salvamento
const response = await TServicoEtiquetaSaveService(data);
// Guardar os dados localizados
setTServicoEtiquetaSave(response.data);
// Manda a resposta para o verificador de resposta global
///setResponse(response);
// Manda a resposta para o verificador de resposta global
return response.data;
};
// Retorna o estado e a função de salvamento para uso no componente
return { tServicoEtiquetaSave, fetchTServicoEtiquetaSave };
};

25
src/app/(protected)/(cadastros)/cadastros/_hooks/t_servico_tipo/useTServicoTipoEditHook.ts Normal file
View file

@ -0,0 +1,25 @@
import { useResponse } from '@/shared/components/response/ResponseContext'; // Contexto global para gerenciar respostas da API
// Interface tipada do tipo de serviço
import TServicoTipoInterface from '../../_interfaces/TServicoTipoInterface';
// Função que Edit o tipo de serviço via API
import { TServicoTipoEditData } from '../../_data/TServicoTipo/TServicoTipoEditData';
// Hook customizado para remoção de tipos de serviço
export const useTServicoTipoEditHook = () => {
// Hook do contexto de resposta para feedback global (alertas, mensagens etc.)
const { setResponse } = useResponse();
// Função assíncrona que Edit um tipo de serviço
const editTServicoTipo = async (data: TServicoTipoInterface) => {
// Chama a função de remoção passando os dados do tipo de serviço
const response = await TServicoTipoEditData(data);
// Atualiza o contexto global com a resposta da API
setResponse(response);
};
// Retorna a função de remoção para ser usada no componente
return { editTServicoTipo };
};

35
src/app/(protected)/(cadastros)/cadastros/_hooks/t_servico_tipo/useTServicoTipoReadHook.ts Normal file
View file

@ -0,0 +1,35 @@
import { useResponse } from '@/shared/components/response/ResponseContext'; // Contexto global para gerenciar respostas da API
import { useState } from 'react';
// Serviço que busca a lista de tipos de serviço (TServicoTipoIndexService)
import { TServicoTipoIndexService } from '../../_services/t_servico_tipo/TServicoTipoIndexService';
// Interface tipada do tipo de serviço
import TServicoTipoInterface from '../../_interfaces/TServicoTipoInterface';
// Hook customizado para leitura de dados de tipos de serviço
export const useTServicoTipoReadHook = () => {
// Hook do contexto de resposta para feedback global (alertas, mensagens etc.)
const { setResponse } = useResponse();
// Estado local que armazena a lista de tipos de serviço retornada da API
const [tServicoTipo, setTServicoTipo] = useState<TServicoTipoInterface[]>([]);
// Função assíncrona que busca os dados dos tipos de serviço
const fetchTServicoTipo = async () => {
// Chama o serviço responsável por consultar a API
const response = await TServicoTipoIndexService();
// Atualiza o estado local com os dados retornados
setTServicoTipo(response.data);
// Atualiza o contexto global de resposta
setResponse(response);
// Retorna a resposta para quem chamou o hook
return response;
};
// Retorna os dados e a função de busca para serem usados no componente
return { tServicoTipo, fetchTServicoTipo };
};

25
src/app/(protected)/(cadastros)/cadastros/_hooks/t_servico_tipo/useTServicoTipoRemoveHook.ts Normal file
View file

@ -0,0 +1,25 @@
import { useResponse } from '@/shared/components/response/ResponseContext'; // Contexto global para gerenciar respostas da API
// Interface tipada do tipo de serviço
import TServicoTipoInterface from '../../_interfaces/TServicoTipoInterface';
// Função que remove o tipo de serviço via API
import { TServicoTipoRemoveData } from '../../_data/TServicoTipo/TServicoTipoRemoveData';
// Hook customizado para remoção de tipos de serviço
export const useTServicoTipoRemoveHook = () => {
// Hook do contexto de resposta para feedback global (alertas, mensagens etc.)
const { setResponse } = useResponse();
// Função assíncrona que remove um tipo de serviço
const removeTServicoTipo = async (data: TServicoTipoInterface) => {
// Chama a função de remoção passando os dados do tipo de serviço
const response = await TServicoTipoRemoveData(data);
// Atualiza o contexto global com a resposta da API
setResponse(response);
};
// Retorna a função de remoção para ser usada no componente
return { removeTServicoTipo };
};

33
src/app/(protected)/(cadastros)/cadastros/_hooks/t_servico_tipo/useTServicoTipoSaveHook.ts Normal file
View file

@ -0,0 +1,33 @@
import { useState } from 'react';
import { useResponse } from '@/shared/components/response/ResponseContext';
// Interface tipada do tipo de serviço
import TServicoTipoInterface from '../../_interfaces/TServicoTipoInterface';
// Serviço que salva os dados do tipo de serviço
import { TServicoTipoSaveService } from '../../_services/t_servico_tipo/TServicoTipoSaveService';
export const useTServicoTipoSaveHook = () => {
const { setResponse } = useResponse();
// Estado local para armazenar os dados do tipo de serviço salvos
const [tServicoTipo, setTServicoTipo] = useState<TServicoTipoInterface | null>(null);
/**
* Função que executa o salvamento de um tipo de serviço.
* @param data Os dados do tipo de serviço a serem salvos.
*/
const saveTServicoTipo = async (data: TServicoTipoInterface) => {
// Chama o serviço de salvamento
const response = await TServicoTipoSaveService(data);
// Guardar os dados localizados
setTServicoTipo(response.data);
// Manda a resposta para o verificador de resposta global
setResponse(response);
};
// Retorna o estado e a função de salvamento para uso no componente
return { tServicoTipo, saveTServicoTipo };
};

41
src/app/(protected)/(cadastros)/cadastros/_hooks/t_tb_reconhecimentotipo/useTTBReconhecimentoTipoReadHook.ts Normal file
View file

@ -0,0 +1,41 @@
// Importa o hook responsável por gerenciar e exibir respostas globais (sucesso, erro, etc.)
import { useResponse } from '@/shared/components/response/ResponseContext';
// Importa hooks do React para gerenciamento de estado e memorização de valores
import { useMemo, useState } from 'react';
// Importa a interface que define a estrutura dos dados de "TTBReconhecimentoTipo"
import { TTBReconhecimentoTipoReadInterface } from '../../_interfaces/TTBReconhecimentoTipoReadInterface';
import { TTBReconhecimentoTipoInterface } from '../../_interfaces/TTBReconhecimentoTipoInterface';
// Importa o serviço responsável por buscar os dados de "TTBReconhecimentoTipo" na API
import { TTBReconhecimentoTipoIndexService } from '../../_services/t_tb_reconhecimentotipo/TTBReconhecimentoTipoIndexService';
// Hook personalizado para leitura (consulta) dos tipos de marcação
export const useTTBReconhecimentoTipoReadHook = () => {
// Obtém a função que atualiza a resposta global do sistema
const { setResponse } = useResponse();
// Define o estado local que armazenará a lista de tipos de marcação
const [tTBReconhecimentoTipo, setTTBReconhecimentoTipo] = useState<
TTBReconhecimentoTipoInterface[]
>([]);
// Função responsável por buscar os dados da API e atualizar o estado
const fetchTTBReconhecimentoTipo = async (data: TTBReconhecimentoTipoReadInterface) => {
// Executa o serviço que faz a requisição à API
const response = await TTBReconhecimentoTipoIndexService(data);
// Atualiza o estado local com os dados retornados
setTTBReconhecimentoTipo(response.data);
// Atualiza o contexto global de resposta (ex: para exibir alertas ou mensagens)
setResponse(response);
};
// Retorna os dados e a função de busca, memorizando o valor para evitar recriações desnecessárias
return useMemo(
() => ({ tTBReconhecimentoTipo, fetchTTBReconhecimentoTipo }),
[tTBReconhecimentoTipo, fetchTTBReconhecimentoTipo],
);
};

17
src/app/(protected)/(cadastros)/cadastros/_interfaces/CCaixaServicoInterface.ts Normal file
View file

@ -0,0 +1,17 @@
// Interface que representa a tabela C_CAIXA_SERVICO
export interface CCaixaServicoInterface {
interno_sistema?: string; // VARCHAR(1)
caixa_servico_id: number; // NUMERIC(10,2) NOT NULL - Chave primária
descricao?: string; // VARCHAR(60)
situacao?: string; // VARCHAR(1)
tipo_transacao?: string; // VARCHAR(1)
sistema_id?: number; // NUMERIC(14,3)
selo_grupo_id?: number; // NUMERIC(10,2)
emitir_relatorio?: string; // VARCHAR(1)
repasse?: string; // VARCHAR(1)
repetir_descricao?: string; // VARCHAR(1)
codigo_conta?: number; // NUMERIC(10,2)
tipo_conta_carneleao?: string; // VARCHAR(60)
centro_de_custa_id?: number; // NUMERIC(10,2) - Chave estrangeira
devolucao_juizo?: string; // VARCHAR(1)
}

3
src/app/(protected)/(cadastros)/cadastros/_interfaces/CCaixaServicoReadInterface.ts Normal file
View file

@ -0,0 +1,3 @@
export interface CCaixaServicoReadInterface {
sistema_id?: number;
}

20
src/app/(protected)/(cadastros)/cadastros/_interfaces/GEmolumentoInterface.ts Normal file
View file

@ -0,0 +1,20 @@
// Interface que representa a tabela G_EMOLUMENTO
export interface GEmolumentoInterface {
emolumento_id?: number; // NUMERIC(10,2) - Chave primária
descricao?: string; // VARCHAR(260)
tipo?: string; // VARCHAR(1)
sistema_id?: number; // NUMERIC(10,2)
selo_grupo_id?: number; // NUMERIC(10,2)
reg_averb?: string; // VARCHAR(1)
pre_definido?: string; // VARCHAR(1)
situacao?: string; // VARCHAR(1)
situacao_ri?: string; // VARCHAR(1)
com_reducao?: string; // VARCHAR(1)
motivo_reducao?: string; // VARCHAR(120)
valor_maximo_certidao?: number; // NUMERIC(14,3)
tipo_objetivo?: string; // VARCHAR(3)
modelo_tag?: string; // VARCHAR(3)
codigo_nota_id?: number; // NUMERIC(10,2)
convenio_codhab?: string; // VARCHAR(1)
item_df?: string; // VARCHAR(10)
}

32
src/app/(protected)/(cadastros)/cadastros/_interfaces/GEmolumentoItemInterface.ts Normal file
View file

@ -0,0 +1,32 @@
// Interface que representa a tabela G_EMOLUMENTO_ITEM (inferido)
export interface GEmolumentoItemInterface {
valor_emolumento?: number; // NUMERIC(14,3)
emolumento_item_id: number; // NUMERIC(10,2) NOT NULL - Chave primária (assumida)
emolumento_id?: number; // NUMERIC(10,2)
valor_inicio?: number; // NUMERIC(14,3)
valor_fim?: number; // NUMERIC(14,3)
valor_taxa_judiciaria?: number; // NUMERIC(14,3)
emolumento_periodo_id?: number; // NUMERIC(10,2)
codigo?: number; // NUMERIC(10,2)
pagina_extra?: number; // NUMERIC(10,2)
valor_pagina_extra?: number; // NUMERIC(14,3)
valor_outra_taxa1?: number; // NUMERIC(14,3)
codigo_selo?: string; // VARCHAR(30)
valor_fundo_ri?: number; // NUMERIC(14,3)
codigo_tabela?: string; // VARCHAR(30)
selo_grupo_id?: number; // NUMERIC(10,2)
codigo_km?: string; // VARCHAR(30)
emolumento_acresce?: number; // NUMERIC(14,3)
taxa_acresce?: number; // NUMERIC(14,3)
funcivil_acresce?: number; // NUMERIC(14,3)
valor_fracao?: number; // NUMERIC(14,3)
valor_por_excedente_emol?: number; // NUMERIC(14,3)
valor_por_excedente_tj?: number; // NUMERIC(14,3)
valor_por_excedente_fundo?: number; // NUMERIC(14,3)
valor_limite_excedente_emol?: number; // NUMERIC(14,3)
valor_limite_excedente_tj?: number; // NUMERIC(14,3)
valor_limite_excedente_fundo?: number; // NUMERIC(14,3)
fundo_selo?: number; // NUMERIC(14,3)
distribuicao?: number; // NUMERIC(14,3)
vrc_ext?: number; // NUMERIC(10,2) - Renomeado de VRCEXT para vrc_ext (convenção)
}

4
src/app/(protected)/(cadastros)/cadastros/_interfaces/GEmolumentoItemReadInterface.ts Normal file
View file

@ -0,0 +1,4 @@
export interface GEmolumentoItemReadInterface {
emolumento_id?: number;
valor?: number;
}

3
src/app/(protected)/(cadastros)/cadastros/_interfaces/GEmolumentoReadInterface.ts Normal file
View file

@ -0,0 +1,3 @@
export interface GEmolumentoReadInterface {
sistema_id?: number;
}

20
src/app/(protected)/(cadastros)/cadastros/_interfaces/GMarcacaoTipoInterface.ts Normal file
View file

@ -0,0 +1,20 @@
export interface GMarcacaoTipoInterface {
marcacao_tipo_id?: number;
descricao?: string;
texto?: string; // Mapeamento para BLOB SUB_TYPE BINARY
nome?: string;
grupo?: string;
situacao?: string;
sistema_id?: number;
grupo_tipo?: string;
tipo_qualificacao?: string;
condicao_sql?: string;
separador_1?: string;
separador_2?: string;
separador_3?: string;
tipo_valor?: string;
atualizar?: string;
protegida?: string;
ativar_separador?: string;
sql_completo?: string;
}

5
src/app/(protected)/(cadastros)/cadastros/_interfaces/GMarcacaoTipoReadInterface.ts Normal file
View file

@ -0,0 +1,5 @@
export interface GMarcacaoTipoReadInterface {
grupo?: string;
sistema_id?: number;
situacao?: string;
}

7
src/app/(protected)/(cadastros)/cadastros/_interfaces/TServicoEtiquetaInterface.ts Normal file
View file

@ -0,0 +1,7 @@
// Interface que representa a tabela T_TB_RECONHECIMENTOTIPO
export interface TServicoEtiquetaInterface {
servico_etiqueta_id?: number; // NUMERIC(10,2) NOT NULL - Chave primária
etiqueta_modelo_id?: number; // NUMERIC(10,2)
servico_tipo_id?: number; // NUMERIC(10,2)
descricao?: string;
}

3
src/app/(protected)/(cadastros)/cadastros/_interfaces/TServicoEtiquetaServicoIdReadInterface.ts Normal file
View file

@ -0,0 +1,3 @@
export interface TServicoEtiquetaServicoIdReadInterface {
servico_tipo_id?: number;
}

27
src/app/(protected)/(cadastros)/cadastros/_interfaces/TServicoTipoInterface.ts Normal file
View file

@ -0,0 +1,27 @@
export default interface TServicoTipoInterface {
servico_tipo_id?: number; // SERVICO_TIPO_ID NUMERIC(10,2) NOT NULL (PK)
descricao: string; // DESCRICAO VARCHAR(60)
valor?: number; // VALOR NUMERIC(14,3)
requer_autorizacao?: string; // REQUER_AUTORIZACAO VARCHAR(1)
requer_biometria?: string; // REQUER_BIOMETRIA VARCHAR(1)
tipo_pessoa?: string; // TIPO_PESSOA VARCHAR(1)
tb_reconhecimentotipo_id?: number; // TB_RECONHECIMENTOTIPO_ID NUMERIC(10,2) (FK)
requer_abonador?: string; // REQUER_ABONADOR VARCHAR(1)
situacao?: string; // SITUACAO VARCHAR(1)
requer_cpf?: string; // REQUER_CPF VARCHAR(1)
servico_padrao?: string; // SERVICO_PADRAO VARCHAR(1)
maximo_pessoa?: number; // MAXIMO_PESSOA NUMERIC(10,2)
alterar_valor?: string; // ALTERAR_VALOR VARCHAR(1)
servico_caixa_id?: number; // SERVICO_CAIXA_ID NUMERIC(10,2)
caixa_servico_id?: number; // LIBERAR_DESCONTO VARCHAR(1)
valor_fixo?: string; // VALOR_FIXO VARCHAR(1)
emolumento_id?: number; // EMOLUMENTO_ID NUMERIC(10,2) (FK)
emolumento_obrigatorio?: number; // EMOLUMENTO_OBRIGATORIO NUMERIC(10,2) (FK)
ato_praticado?: string; // ATO_PRATICADO VARCHAR(1)
selar?: string; // SELAR VARCHAR(1)
frenteverso?: string; // FRENTEVERSO VARCHAR(1)
etiqueta_unica?: string; // ETIQUETA_UNICA VARCHAR(1)
transferencia_veiculo?: string; // TRANSFERENCIA_VEICULO VARCHAR(1)
usar_a4?: string; // USAR_A4 VARCHAR(1)
averbacao?: string; // AVERBACAO VARCHAR(1)
}

6
src/app/(protected)/(cadastros)/cadastros/_interfaces/TTBReconhecimentoTipoInterface.ts Normal file
View file

@ -0,0 +1,6 @@
// Interface que representa a tabela T_TB_RECONHECIMENTOTIPO
export interface TTbReconhecimentoTipoInterface {
tb_reconhecimentotipo_id: number; // NUMERIC(10,2) NOT NULL - Chave primária
descricao?: string; // VARCHAR(30)
situacao?: string; // VARCHAR(1)
}

4
src/app/(protected)/(cadastros)/cadastros/_interfaces/TTBReconhecimentoTipoReadInterface.ts Normal file
View file

@ -0,0 +1,4 @@
export interface TTBReconhecimentoTipoReadInterface {
tb_reconhecimentotipo_id?: number;
descricao?: string;
}

14
src/app/(protected)/(cadastros)/cadastros/_schemas/TServicoEtiquetaSchema.ts Normal file
View file

@ -0,0 +1,14 @@
/**
* Interface principal baseada na DDL
* Tabela: T_SERVICO_ETIQUETA
*/
export interface TServicoEtiquetaFormValues {
/** Identificador principal (PK) */
servico_etiqueta_id?: number;
/** Relacionamento com o modelo de etiqueta (FK) */
etiqueta_modelo_id?: number;
/** Relacionamento com o tipo de serviço (FK) */
servico_tipo_id?: number;
}

78
src/app/(protected)/(cadastros)/cadastros/_schemas/TServicoTipoSchema.ts Normal file
View file

@ -0,0 +1,78 @@
import z from 'zod';
/**
* Tipos utilitários para campos simples
*/
const SN = z.enum(['S', 'N']).default('N'); // Campos do tipo Sim/Não
const AI = z.enum(['A', 'I']).default('A'); // Situação Ativo/Inativo
const OneCharString = z.string().max(1, 'Deve ter no máximo 1 caractere').optional();
const RequiredString = z.string().min(1, 'O campo é obrigatório');
const OptionalNumber = z.number().optional();
const RequiredNumber = z.number();
/**
* Schema principal baseado na DDL e adaptado ao formulário React
*/
export const TServicoTipoSchema = z.object({
// Identificador
servico_tipo_id: RequiredNumber.describe('ID do Tipo de Serviço').optional(),
// Campos principais
descricao: z.string().max(60, 'A descrição deve ter no máximo 60 caracteres').optional(),
categoria: z.string().optional(),
// Controle de flags (S/N)
frenteverso: SN.optional(),
averbacao: SN.optional(),
transferencia_veiculo: SN.optional(),
usar_a4: SN.optional(),
etiqueta_unica: SN.optional(),
selar: SN.optional(),
servico_padrao: SN.optional(),
// lancar_taxa: SN.optional(),
// lancar_fundesp: SN.optional(),
// liberar_desconto: SN.optional(),
// fundesp_automatica: SN.optional(),
// lancar_valor_documento: SN.optional(),
valor_fixo: SN.optional(),
ato_praticado: SN.optional(),
// apresentante_selo: SN.optional(),
// renovacao_cartao: SN.optional(),
// Situação
situacao: AI,
// Campos numéricos
valor: OptionalNumber,
maximo_pessoa: OptionalNumber,
servico_caixa_id: OptionalNumber,
emolumento_id: z.number().nullable(),
emolumento_obrigatorio: z.number().nullable(),
// Relacionamentos e permissões
tipo_item: OneCharString,
requer_autorizacao: OneCharString,
requer_biometria: OneCharString,
tipo_pessoa: OneCharString,
tb_reconhecimentotipo_id: OptionalNumber,
// tipo_permissao_cpf: OneCharString,
requer_abonador: OneCharString,
// requer_representante: OneCharString,
requer_cpf: OneCharString,
// alterar_valor: OneCharString,
// pagina_acrescida: OneCharString,
// Campos auxiliares usados apenas no formulário (não persistidos)
valor_emolumento: z.number().optional(),
valor_taxa_judiciaria: z.number().optional(),
fundesp_valor: z.number().optional(),
valor_total: z.number().optional(),
etiquetas_carimbos: z.any().optional(),
emolumento: z.any().optional(),
emolumento_auxiliar: z.any().optional(),
});
/**
* Tipo inferido do schema — usado diretamente no useForm
*/
export type TServicoTipoFormValues = z.infer<typeof TServicoTipoSchema>;

18
src/app/(protected)/(cadastros)/cadastros/_services/c_caixa_servico/CCaixaServicoIndexService.ts Normal file
View file

@ -0,0 +1,18 @@
// Importa o utilitário responsável por lidar com erros de forma padronizada no cliente
import { withClientErrorHandler } from '@/shared/actions/withClientErrorHandler/withClientErrorHandler';
// Importa a função que realiza a requisição de listagem dos tipos de marcação
import { CCaixaServicoIndexData } from '../../_data/CCaixaServico/CCaixaServicoIndexData';
import { CCaixaServicoReadInterface } from '../../_interfaces/CCaixaServicoReadInterface';
// Função assíncrona responsável por executar o serviço de listagem de tipos de marcação
async function executeCCaixaServicoIndexService(data: CCaixaServicoReadInterface) {
// Chama a função que realiza a requisição à API e aguarda a resposta
const response = await CCaixaServicoIndexData(data);
// Retorna a resposta obtida da requisição
return response;
}
// Exporta o serviço encapsulado pelo handler de erro, garantindo tratamento uniforme em caso de falhas
export const CCaixaServicoIndexService = withClientErrorHandler(executeCCaixaServicoIndexService);

18
src/app/(protected)/(cadastros)/cadastros/_services/g_emolumento/GEmolumentoIndexService.ts Normal file
View file

@ -0,0 +1,18 @@
// Importa o utilitário responsável por lidar com erros de forma padronizada no cliente
import { withClientErrorHandler } from '@/shared/actions/withClientErrorHandler/withClientErrorHandler';
// Importa a função que realiza a requisição de listagem dos tipos de marcação
import { GEmolumentoIndexData } from '../../_data/GEmolumento/GEmolumentoIndexData';
import { GEmolumentoReadInterface } from '../../_interfaces/GEmolumentoReadInterface';
// Função assíncrona responsável por executar o serviço de listagem de tipos de marcação
async function executeGEmolumentoIndexService(data: GEmolumentoReadInterface) {
// Chama a função que realiza a requisição à API e aguarda a resposta
const response = await GEmolumentoIndexData(data);
// Retorna a resposta obtida da requisição
return response;
}
// Exporta o serviço encapsulado pelo handler de erro, garantindo tratamento uniforme em caso de falhas
export const GEmolumentoIndexService = withClientErrorHandler(executeGEmolumentoIndexService);

20
src/app/(protected)/(cadastros)/cadastros/_services/g_emolumento_item/GEmolumentoItemValorService.ts Normal file
View file

@ -0,0 +1,20 @@
// Importa o utilitário responsável por lidar com erros de forma padronizada no cliente
import { withClientErrorHandler } from '@/shared/actions/withClientErrorHandler/withClientErrorHandler';
// Importa a função que realiza a requisição de listagem dos tipos de marcação
import { GEmolumentoItemValorData } from '../../_data/GEmolumentoItem/GEmolumentoItemValorData';
import { GEmolumentoItemReadInterface } from '../../_interfaces/GEmolumentoItemReadInterface';
// Função assíncrona responsável por executar o serviço de listagem de tipos de marcação
async function executeGEmolumentoItemValorService(data: GEmolumentoItemReadInterface) {
// Chama a função que realiza a requisição à API e aguarda a resposta
const response = await GEmolumentoItemValorData(data);
// Retorna a resposta obtida da requisição
return response;
}
// Exporta o serviço encapsulado pelo handler de erro, garantindo tratamento uniforme em caso de falhas
export const GEmolumentoItemValorService = withClientErrorHandler(
executeGEmolumentoItemValorService,
);

18
src/app/(protected)/(cadastros)/cadastros/_services/g_marcacao_tipo/GMarcacaoTipoIndexService.ts Normal file
View file

@ -0,0 +1,18 @@
// Importa o utilitário responsável por lidar com erros de forma padronizada no cliente
import { withClientErrorHandler } from '@/shared/actions/withClientErrorHandler/withClientErrorHandler';
// Importa a função que realiza a requisição de listagem dos tipos de marcação
import { GMarcacaoTipoIndexData } from '../../_data/GMarcacaoTipo/GMarcacaoTipoIndexData';
import { GMarcacaoTipoReadInterface } from '../../_interfaces/GMarcacaoTipoReadInterface';
// Função assíncrona responsável por executar o serviço de listagem de tipos de marcação
async function executeGMarcacaoTipoIndexService(data: GMarcacaoTipoReadInterface) {
// Chama a função que realiza a requisição à API e aguarda a resposta
const response = await GMarcacaoTipoIndexData(data);
// Retorna a resposta obtida da requisição
return response;
}
// Exporta o serviço encapsulado pelo handler de erro, garantindo tratamento uniforme em caso de falhas
export const GMarcacaoTipoIndexService = withClientErrorHandler(executeGMarcacaoTipoIndexService);

22
src/app/(protected)/(cadastros)/cadastros/_services/t_servico_etiqueta/TServicoEtiquetaSaveService.ts Normal file
View file

@ -0,0 +1,22 @@
// Função que envolve qualquer ação assíncrona para capturar e tratar erros do cliente
import { withClientErrorHandler } from '@/shared/actions/withClientErrorHandler/withClientErrorHandler';
// Função que salva os dados do serviço etiqueta via API (ou mock)
import { TServicoEtiquetaSaveData } from '../../_data/TServicoEtiqueta/TServicoEtiquetaSaveData';
// Interface tipada do serviço etiqueta
import { TServicoEtiquetaInterface } from '../../_interfaces/TServicoEtiquetaInterface';
// Função assíncrona que executa o salvamento de um serviço etiqueta
async function executeTServicoEtiquetaSaveService(data: TServicoEtiquetaInterface) {
// Chama a função que salva os dados do serviço etiqueta
const response = await TServicoEtiquetaSaveData(data);
// Retorna a resposta do salvamento
return response;
}
// Exporta o serviço de salvamento de serviço etiqueta já encapsulado com tratamento de erros
export const TServicoEtiquetaSaveService = withClientErrorHandler(
executeTServicoEtiquetaSaveService,
);

21
src/app/(protected)/(cadastros)/cadastros/_services/t_servico_etiqueta/TServicoEtiquetaServicoIdService.ts Normal file
View file

@ -0,0 +1,21 @@
import { withClientErrorHandler } from '@/shared/actions/withClientErrorHandler/withClientErrorHandler';
// Função que envolve qualquer ação assíncrona para capturar e tratar erros do cliente
import { TServicoEtiquetaReadData } from '../../_data/TServicoEtiqueta/TServicoEtiquetaReadData';
import { TServicoEtiquetaInterface } from '../../_interfaces/TServicoEtiquetaInterface';
// Interface tipada do tipo de serviço
// Função assíncrona que executa a consulta de um tipo de serviço etiqueta
async function executeTServicoEtiquetaServicoIdService(data: TServicoEtiquetaInterface) {
// Chama a função que consulta os dados do tipo de serviço etiqueta
const response = await TServicoEtiquetaReadData(data);
// Retorna a resposta da remoção
return response;
}
// Exporta o serviço de remoção de tipo de serviço já encapsulado com tratamento de erros
export const TServicoEtiquetaServicoIdService = withClientErrorHandler(
executeTServicoEtiquetaServicoIdService,
);

20
src/app/(protected)/(cadastros)/cadastros/_services/t_servico_tipo/TServicoTipoEditService.ts Normal file
View file

@ -0,0 +1,20 @@
import { withClientErrorHandler } from '@/shared/actions/withClientErrorHandler/withClientErrorHandler';
// Função que envolve qualquer ação assíncrona para capturar e tratar erros do cliente
import { TServicoTipoEditData } from '../../_data/TServicoTipo/TServicoTipoEditData';
// Função que remove os dados do tipo de serviço via API
import TServicoTipoInterface from '../../_interfaces/TServicoTipoInterface';
// Interface tipada do tipo de serviço
// Função assíncrona que executa a remoção de um tipo de serviço
async function executeTServicoTipoEditService(data: TServicoTipoInterface) {
// Chama a função que remove os dados do tipo de serviço
const response = await TServicoTipoEditData(data);
// Retorna a resposta da remoção
return response;
}
// Exporta o serviço de remoção de tipo de serviço já encapsulado com tratamento de erros
export const TServicoTipoEditService = withClientErrorHandler(executeTServicoTipoEditService);

17
src/app/(protected)/(cadastros)/cadastros/_services/t_servico_tipo/TServicoTipoIndexService.ts Normal file
View file

@ -0,0 +1,17 @@
import { withClientErrorHandler } from '@/shared/actions/withClientErrorHandler/withClientErrorHandler';
// Função que envolve qualquer ação assíncrona para capturar e tratar erros do cliente
import { TServicoTipoIndexData } from '../../_data/TServicoTipo/TServicoTipoIndexData';
// Função que retorna os dados da lista de tipos de serviço (chamada à API ou mock)
// Função assíncrona que executa a chamada para buscar os dados dos tipos de serviço
async function executeTServicoTipoIndexService() {
// Chama a função que retorna os dados dos tipos de serviço
const response = await TServicoTipoIndexData();
// Retorna a resposta para o chamador
return response;
}
// Exporta o serviço de índice de tipos de serviço já encapsulado com tratamento de erros
export const TServicoTipoIndexService = withClientErrorHandler(executeTServicoTipoIndexService);

20
src/app/(protected)/(cadastros)/cadastros/_services/t_servico_tipo/TServicoTipoRemoveService.ts Normal file
View file

@ -0,0 +1,20 @@
import { withClientErrorHandler } from '@/shared/actions/withClientErrorHandler/withClientErrorHandler';
// Função que envolve qualquer ação assíncrona para capturar e tratar erros do cliente
import { TServicoTipoRemoveData } from '../../_data/TServicoTipo/TServicoTipoRemoveData';
// Função que remove os dados do tipo de serviço via API
import TServicoTipoInterface from '../../_interfaces/TServicoTipoInterface';
// Interface tipada do tipo de serviço
// Função assíncrona que executa a remoção de um tipo de serviço
async function executeTServicoTipoRemoveService(data: TServicoTipoInterface) {
// Chama a função que remove os dados do tipo de serviço
const response = await TServicoTipoRemoveData(data);
// Retorna a resposta da remoção
return response;
}
// Exporta o serviço de remoção de tipo de serviço já encapsulado com tratamento de erros
export const TServicoTipoRemoveService = withClientErrorHandler(executeTServicoTipoRemoveService);

20
src/app/(protected)/(cadastros)/cadastros/_services/t_servico_tipo/TServicoTipoSaveService.ts Normal file
View file

@ -0,0 +1,20 @@
// Função que envolve qualquer ação assíncrona para capturar e tratar erros do cliente
import { withClientErrorHandler } from '@/shared/actions/withClientErrorHandler/withClientErrorHandler';
// Função que salva os dados do tipo de serviço via API (ou mock)
import { TServicoTipoSaveData } from '../../_data/TServicoTipo/TServicoTipoSaveData';
// Interface tipada do tipo de serviço
import TServicoTipoInterface from '../../_interfaces/TServicoTipoInterface';
// Função assíncrona que executa o salvamento de um tipo de serviço
async function executeTServicoTipoSaveService(data: TServicoTipoInterface) {
// Chama a função que salva os dados do tipo de serviço
const response = await TServicoTipoSaveData(data);
// Retorna a resposta do salvamento
return response;
}
// Exporta o serviço de salvamento de tipo de serviço já encapsulado com tratamento de erros
export const TServicoTipoSaveService = withClientErrorHandler(executeTServicoTipoSaveService);

20
src/app/(protected)/(cadastros)/cadastros/_services/t_tb_reconhecimentotipo/TTBReconhecimentoTipoIndexService.ts Normal file
View file

@ -0,0 +1,20 @@
// Importa o utilitário responsável por lidar com erros de forma padronizada no cliente
import { withClientErrorHandler } from '@/shared/actions/withClientErrorHandler/withClientErrorHandler';
// Importa a função que realiza a requisição de listagem dos tipos de marcação
import { TTBReconhecimentoTipoIndexData } from '../../_data/TTBReconhecimentoTipo/TTBReconhecimentoTipoIndexData';
import { TTBReconhecimentoTipoReadInterface } from '../../_interfaces/TTBReconhecimentoTipoReadInterface';
// Função assíncrona responsável por executar o serviço de listagem de tipos de marcação
async function executeTTBReconhecimentoTipoIndexService(data: TTBReconhecimentoTipoReadInterface) {
// Chama a função que realiza a requisição à API e aguarda a resposta
const response = await TTBReconhecimentoTipoIndexData(data);
// Retorna a resposta obtida da requisição
return response;
}
// Exporta o serviço encapsulado pelo handler de erro, garantindo tratamento uniforme em caso de falhas
export const TTBReconhecimentoTipoIndexService = withClientErrorHandler(
executeTTBReconhecimentoTipoIndexService,
);

8
src/app/(protected)/layout.tsx
View file

@ -56,15 +56,11 @@ export default function RootLayout({
<Breadcrumb>
<BreadcrumbList>
<BreadcrumbItem className="hidden md:block">
<BreadcrumbLink href="#">
Building Your Application
</BreadcrumbLink>
<BreadcrumbLink href="#">Building Your Application</BreadcrumbLink>
</BreadcrumbItem>
<BreadcrumbSeparator className="hidden md:block" />
<BreadcrumbItem>
<BreadcrumbPage>
Data Fetching
</BreadcrumbPage>
<BreadcrumbPage>Data Fetching</BreadcrumbPage>
</BreadcrumbItem>
</BreadcrumbList>
</Breadcrumb>

74
src/app/(protected)/page.tsx
View file

@ -4,51 +4,47 @@ import useGUsuarioGetJWTHook from '@/shared/hooks/auth/useGUsuarioGetJWTHook';
import { useEffect, useState } from 'react';
export default function Page() {
const { userAuthenticated } = useGUsuarioGetJWTHook();
const { userAuthenticated } = useGUsuarioGetJWTHook();
// Inicializa time como null para renderizar só no cliente
const [time, setTime] = useState<Date | null>(null);
// Inicializa time como null para renderizar só no cliente
const [time, setTime] = useState<Date | null>(null);
useEffect(() => {
setTime(new Date()); // define data inicial no cliente
const interval = setInterval(() => setTime(new Date()), 1000);
return () => clearInterval(interval);
}, []);
useEffect(() => {
setTime(new Date()); // define data inicial no cliente
const interval = setInterval(() => setTime(new Date()), 1000);
return () => clearInterval(interval);
}, []);
// Se ainda não temos a hora, renderiza nada para evitar mismatch
if (!time || !userAuthenticated?.data) return null;
// Se ainda não temos a hora, renderiza nada para evitar mismatch
if (!time || !userAuthenticated?.data) return null;
const hours = time.getHours();
const greeting =
hours < 12 ? 'Bom dia' : hours < 18 ? 'Boa tarde' : 'Boa noite';
const hours = time.getHours();
const greeting = hours < 12 ? 'Bom dia' : hours < 18 ? 'Boa tarde' : 'Boa noite';
const formattedDate = time.toLocaleDateString('pt-BR', {
weekday: 'long',
day: '2-digit',
month: 'long',
});
const formattedTime = time.toLocaleTimeString('pt-BR');
const formattedDate = time.toLocaleDateString('pt-BR', {
weekday: 'long',
day: '2-digit',
month: 'long',
});
const formattedTime = time.toLocaleTimeString('pt-BR');
return (
<main className="fixed inset-0 flex flex-col items-center justify-center text-gray-800 overflow-hidden select-none">
<section className="text-center max-w-md px-4">
<h1 className="text-4xl font-bold mb-2">
{greeting},{' '}
<span className="text-blue-600">{userAuthenticated.data.nome}</span>{' '}
👋
</h1>
return (
<main className="fixed inset-0 flex flex-col items-center justify-center overflow-hidden text-gray-800 select-none">
<section className="max-w-md px-4 text-center">
<h1 className="mb-2 text-4xl font-bold">
{greeting}, <span className="text-blue-600">{userAuthenticated.data.nome}</span> 👋
</h1>
<p className="text-gray-600 text-sm mb-6">
Hoje é <strong>{formattedDate}</strong>, {formattedTime}
</p>
<p className="mb-6 text-sm text-gray-600">
Hoje é <strong>{formattedDate}</strong>, {formattedTime}
</p>
<div className="rounded-2xl p-6">
<p className="text-gray-700 leading-relaxed">
Que bom ter você de volta! 🎉
Aproveite o seu dia e continue alcançando seus objetivos.
</p>
</div>
</section>
</main>
);
<div className="rounded-2xl p-6">
<p className="leading-relaxed text-gray-700">
Que bom ter você de volta! 🎉 Aproveite o seu dia e continue alcançando seus objetivos.
</p>
</div>
</section>
</main>
);
}

197
src/app/_components/confirm_exclusion/ConfirmExclusion.tsx
View file

@ -2,123 +2,110 @@
import React, { useState } from 'react';
import {
AlertDialog,
AlertDialogCancel,
AlertDialogContent,
AlertDialogDescription,
AlertDialogFooter,
AlertDialogHeader,
AlertDialogTitle,
AlertDialogAction,
AlertDialog,
AlertDialogCancel,
AlertDialogContent,
AlertDialogDescription,
AlertDialogFooter,
AlertDialogHeader,
AlertDialogTitle,
AlertDialogAction,
} from '@/components/ui/alert-dialog';
import {
InputOTP,
InputOTPGroup,
InputOTPSlot,
} from '@/components/ui/input-otp';
import { InputOTP, InputOTPGroup, InputOTPSlot } from '@/components/ui/input-otp';
interface ConfirmExclusionProps {
isOpen: boolean;
title: string;
description?: string;
expectedCode: string;
confirmText?: string;
cancelText?: string;
onConfirm: () => void;
onCancel: () => void;
onResendCode: () => void; // Função para reenviar o código
isOpen: boolean;
title: string;
description?: string;
expectedCode: string;
confirmText?: string;
cancelText?: string;
onConfirm: () => void;
onCancel: () => void;
onResendCode: () => void; // Função para reenviar o código
}
export default function ConfirmExclusion({
isOpen,
title,
description,
expectedCode,
confirmText = 'Continuar',
cancelText = 'Cancelar',
onConfirm,
onCancel,
onResendCode, // A função para reenvio do código
isOpen,
title,
description,
expectedCode,
confirmText = 'Continuar',
cancelText = 'Cancelar',
onConfirm,
onCancel,
onResendCode, // A função para reenvio do código
}: ConfirmExclusionProps) {
const [code, setCode] = useState('');
const [isValid, setIsValid] = useState(false);
const [isResending, setIsResending] = useState(false); // Novo estado para controle de envio do código
const [code, setCode] = useState('');
const [isValid, setIsValid] = useState(false);
const [isResending, setIsResending] = useState(false); // Novo estado para controle de envio do código
const handleChange = (value: string) => {
setCode(value);
setIsValid(value === expectedCode);
};
const handleChange = (value: string) => {
setCode(value);
setIsValid(value === expectedCode);
};
const handleResendCode = async () => {
setIsResending(true);
try {
await onResendCode(); // Chamando a função de reenvio
} catch (error) {
console.error("Erro ao reenviar código", error);
} finally {
setIsResending(false); // Resetando o estado de envio
}
};
const handleResendCode = async () => {
setIsResending(true);
try {
await onResendCode(); // Chamando a função de reenvio
} catch (error) {
console.error('Erro ao reenviar código', error);
} finally {
setIsResending(false); // Resetando o estado de envio
}
};
return (
<AlertDialog open={isOpen} onOpenChange={(open) => !open && onCancel()}>
<AlertDialogContent className="max-w-lg mx-auto p-6">
<AlertDialogHeader className="text-center">
<AlertDialogTitle className="text-xl font-semibold text-center">{title}</AlertDialogTitle>
{description && (
<AlertDialogDescription className="mt-2 text-sm text-muted-foreground text-center">
{description}
</AlertDialogDescription>
)}
</AlertDialogHeader>
return (
<AlertDialog open={isOpen} onOpenChange={(open) => !open && onCancel()}>
<AlertDialogContent className="mx-auto max-w-lg p-6">
<AlertDialogHeader className="text-center">
<AlertDialogTitle className="text-center text-xl font-semibold">{title}</AlertDialogTitle>
{description && (
<AlertDialogDescription className="text-muted-foreground mt-2 text-center text-sm">
{description}
</AlertDialogDescription>
)}
</AlertDialogHeader>
<div className="py-4 text-sm text-muted-foreground space-y-4">
<div className="flex justify-center">
<InputOTP
maxLength={expectedCode.length}
value={code}
onChange={handleChange}
>
<InputOTPGroup className="flex gap-4">
{expectedCode.split('').map((_, index) => (
<InputOTPSlot
key={index}
index={index}
className="w-12 h-12 text-center text-lg border-2 border-gray-300 rounded-lg focus:ring-2 focus:ring-blue-500"
/>
))}
</InputOTPGroup>
</InputOTP>
</div>
<div className="text-muted-foreground space-y-4 py-4 text-sm">
<div className="flex justify-center">
<InputOTP maxLength={expectedCode.length} value={code} onChange={handleChange}>
<InputOTPGroup className="flex gap-4">
{expectedCode.split('').map((_, index) => (
<InputOTPSlot
key={index}
index={index}
className="h-12 w-12 rounded-lg border-2 border-gray-300 text-center text-lg focus:ring-2 focus:ring-blue-500"
/>
))}
</InputOTPGroup>
</InputOTP>
</div>
{/* Botão "Reenviar Código" */}
<div className="flex justify-center items-center text-center gap-2 mt-4">
<AlertDialogDescription>
Não recebeu o código?
</AlertDialogDescription>
<button
onClick={handleResendCode}
className={`text-blue-500 font-semibold cursor-pointer ${isResending ? 'cursor-not-allowed text-gray-400' : 'hover:text-blue-600'}`}
disabled={isResending} // Desabilita o botão enquanto o código está sendo reenviado
>
{isResending ? 'Enviando...' : 'Reenviar Código'}
</button>
</div>
</div>
{/* Botão "Reenviar Código" */}
<div className="mt-4 flex items-center justify-center gap-2 text-center">
<AlertDialogDescription>Não recebeu o código?</AlertDialogDescription>
<button
onClick={handleResendCode}
className={`cursor-pointer font-semibold text-blue-500 ${isResending ? 'cursor-not-allowed text-gray-400' : 'hover:text-blue-600'}`}
disabled={isResending} // Desabilita o botão enquanto o código está sendo reenviado
>
{isResending ? 'Enviando...' : 'Reenviar Código'}
</button>
</div>
</div>
<AlertDialogFooter>
<AlertDialogCancel onClick={onCancel} className="text-gray-600 hover:text-gray-800">
{cancelText}
</AlertDialogCancel>
<AlertDialogAction
onClick={onConfirm}
disabled={!isValid}
>
{confirmText}
</AlertDialogAction>
</AlertDialogFooter>
</AlertDialogContent>
</AlertDialog>
);
<AlertDialogFooter>
<AlertDialogCancel onClick={onCancel} className="text-gray-600 hover:text-gray-800">
{cancelText}
</AlertDialogCancel>
<AlertDialogAction onClick={onConfirm} disabled={!isValid}>
{confirmText}
</AlertDialogAction>
</AlertDialogFooter>
</AlertDialogContent>
</AlertDialog>
);
}

14
src/app/_components/confirm_exclusion/useConfirmExclusion.ts
View file

@ -1,4 +1,4 @@
import { useCallback, useState } from "react";
import { useCallback, useState } from 'react';
interface UseConfirmExclusionOptions {
onConfirm?: () => void;
@ -6,15 +6,19 @@ interface UseConfirmExclusionOptions {
expectedCode: string; // código que o usuário precisa digitar
}
export function useConfirmExclusion({ onConfirm, onCancel, expectedCode }: UseConfirmExclusionOptions) {
export function useConfirmExclusion({
onConfirm,
onCancel,
expectedCode,
}: UseConfirmExclusionOptions) {
const [isOpen, setIsOpen] = useState(false);
const [code, setCode] = useState("");
const [code, setCode] = useState('');
const [isValid, setIsValid] = useState(false);
const openDialog = useCallback(() => setIsOpen(true), []);
const closeDialog = useCallback(() => {
setIsOpen(false);
setCode(""); // limpa o código quando fecha
setCode(''); // limpa o código quando fecha
setIsValid(false);
}, []);
@ -35,7 +39,7 @@ export function useConfirmExclusion({ onConfirm, onCancel, expectedCode }: UseCo
setCode(value);
setIsValid(value === expectedCode);
},
[expectedCode]
[expectedCode],
);
return {

31
src/components/app-sidebar.tsx
View file

@ -129,8 +129,8 @@ const data = {
url: '/administrativo/pessoas/estados-civis',
},
{
title: "Regimes/Comunhão",
url: "/administrativo/pessoas/regimes-comunhao/",
title: 'Regimes/Comunhão',
url: '/administrativo/pessoas/regimes-comunhao/',
},
{
title: 'Tipo de Medida',
@ -153,12 +153,12 @@ const data = {
url: '/administrativo/minutas/naturezas',
},
{
title: "Censec/Tipo do Ato",
url: "/administrativo/centrais/censec/tipos-atos"
title: 'Censec/Tipo do Ato',
url: '/administrativo/centrais/censec/tipos-atos',
},
{
title: "Censec/Qualidades",
url: "/administrativo/centrais/censec/qualidades"
title: 'Censec/Qualidades',
url: '/administrativo/centrais/censec/qualidades',
},
{
title: 'Censec/Centrais',
@ -169,8 +169,12 @@ const data = {
url: '/administrativo/centrais/censec/naturezas-litigios',
},
{
title: "Atos/Partes Tipos",
url: "/administrativo/atos/partes-tipos",
title: 'Serviços/Tipos',
url: '/cadastros/servicos-tipo/',
},
{
title: 'Atos/Partes Tipos',
url: '/administrativo/atos/partes-tipos',
},
{
title: "Valores de Serviços",
@ -200,7 +204,6 @@ const data = {
title: "Financeiro/Cálculo Rápido",
url: "/administrativo/financeiro/calculo-rapido",
}
],
},
],
@ -229,16 +232,12 @@ export function AppSidebar({ ...props }: React.ComponentProps<typeof Sidebar>) {
alt="Logo do site"
width={100}
height={100}
className='rounded-lg'
className="rounded-lg"
/>
</div>
<div className="flex flex-col gap-0.5 leading-none">
<span className="font-semibold">
Orius Tecnologia
</span>
<span className="">
25.9.1
</span>
<span className="font-semibold">Orius Tecnologia</span>
<span className="">25.9.1</span>
</div>
</a>
</SidebarMenuButton>

4
src/components/nav-main.tsx
View file

@ -31,9 +31,7 @@ export function NavMain({
}) {
return (
<SidebarGroup>
<SidebarGroupLabel>
SAAS
</SidebarGroupLabel>
<SidebarGroupLabel>SAAS</SidebarGroupLabel>
<SidebarMenu>
{items.map((item) => (
<Collapsible

4
src/components/nav-projects.tsx
View file

@ -32,9 +32,7 @@ export function NavProjects({
return (
<SidebarGroup className="group-data-[collapsible=icon]:hidden">
<SidebarGroupLabel>
Escrituras
</SidebarGroupLabel>
<SidebarGroupLabel>Escrituras</SidebarGroupLabel>
<SidebarMenu>
{projects.map((item) => (
<SidebarMenuItem key={item.name}>

51
src/components/ui/input-otp.tsx
View file

@ -1,58 +1,51 @@
"use client"
'use client';
import * as React from "react"
import { OTPInput, OTPInputContext } from "input-otp"
import { MinusIcon } from "lucide-react"
import * as React from 'react';
import { OTPInput, OTPInputContext } from 'input-otp';
import { MinusIcon } from 'lucide-react';
import { cn } from "@/lib/utils"
import { cn } from '@/lib/utils';
function InputOTP({
className,
containerClassName,
...props
}: React.ComponentProps<typeof OTPInput> & {
containerClassName?: string
containerClassName?: string;
}) {
return (
<OTPInput
data-slot="input-otp"
containerClassName={cn(
"flex items-center gap-2 has-disabled:opacity-50",
containerClassName
)}
className={cn("disabled:cursor-not-allowed", className)}
containerClassName={cn('flex items-center gap-2 has-disabled:opacity-50', containerClassName)}
className={cn('disabled:cursor-not-allowed', className)}
{...props}
/>
)
);
}
function InputOTPGroup({ className, ...props }: React.ComponentProps<"div">) {
function InputOTPGroup({ className, ...props }: React.ComponentProps<'div'>) {
return (
<div
data-slot="input-otp-group"
className={cn("flex items-center", className)}
{...props}
/>
)
<div data-slot="input-otp-group" className={cn('flex items-center', className)} {...props} />
);
}
function InputOTPSlot({
index,
className,
...props
}: React.ComponentProps<"div"> & {
index: number
}: React.ComponentProps<'div'> & {
index: number;
}) {
const inputOTPContext = React.useContext(OTPInputContext)
const { char, hasFakeCaret, isActive } = inputOTPContext?.slots[index] ?? {}
const inputOTPContext = React.useContext(OTPInputContext);
const { char, hasFakeCaret, isActive } = inputOTPContext?.slots[index] ?? {};
return (
<div
data-slot="input-otp-slot"
data-active={isActive}
className={cn(
"data-[active=true]:border-ring data-[active=true]:ring-ring/50 data-[active=true]:aria-invalid:ring-destructive/20 dark:data-[active=true]:aria-invalid:ring-destructive/40 aria-invalid:border-destructive data-[active=true]:aria-invalid:border-destructive dark:bg-input/30 border-input relative flex h-9 w-9 items-center justify-center border-y border-r text-sm shadow-xs transition-all outline-none first:rounded-l-md first:border-l last:rounded-r-md data-[active=true]:z-10 data-[active=true]:ring-[3px]",
className
'data-[active=true]:border-ring data-[active=true]:ring-ring/50 data-[active=true]:aria-invalid:ring-destructive/20 dark:data-[active=true]:aria-invalid:ring-destructive/40 aria-invalid:border-destructive data-[active=true]:aria-invalid:border-destructive dark:bg-input/30 border-input relative flex h-9 w-9 items-center justify-center border-y border-r text-sm shadow-xs transition-all outline-none first:rounded-l-md first:border-l last:rounded-r-md data-[active=true]:z-10 data-[active=true]:ring-[3px]',
className,
)}
{...props}
>
@ -63,15 +56,15 @@ function InputOTPSlot({
</div>
)}
</div>
)
);
}
function InputOTPSeparator({ ...props }: React.ComponentProps<"div">) {
function InputOTPSeparator({ ...props }: React.ComponentProps<'div'>) {
return (
<div data-slot="input-otp-separator" role="separator" {...props}>
<MinusIcon />
</div>
)
);
}
export { InputOTP, InputOTPGroup, InputOTPSlot, InputOTPSeparator }
export { InputOTP, InputOTPGroup, InputOTPSlot, InputOTPSeparator };

2
src/components/ui/sidebar.tsx
View file

@ -548,7 +548,7 @@ function SidebarMenuAction({
'peer-data-[size=lg]/menu-button:top-2.5',
'group-data-[collapsible=icon]:hidden',
showOnHover &&
'peer-data-[active=true]/menu-button:text-sidebar-accent-foreground group-focus-within/menu-item:opacity-100 group-hover/menu-item:opacity-100 data-[state=open]:opacity-100 md:opacity-0',
'peer-data-[active=true]/menu-button:text-sidebar-accent-foreground group-focus-within/menu-item:opacity-100 group-hover/menu-item:opacity-100 data-[state=open]:opacity-100 md:opacity-0',
className,
)}
{...props}

23
src/components/ui/switch.tsx
View file

@ -1,31 +1,28 @@
"use client"
'use client';
import * as React from "react"
import * as SwitchPrimitive from "@radix-ui/react-switch"
import * as React from 'react';
import * as SwitchPrimitive from '@radix-ui/react-switch';
import { cn } from "@/lib/utils"
import { cn } from '@/lib/utils';
function Switch({
className,
...props
}: React.ComponentProps<typeof SwitchPrimitive.Root>) {
function Switch({ className, ...props }: React.ComponentProps<typeof SwitchPrimitive.Root>) {
return (
<SwitchPrimitive.Root
data-slot="switch"
className={cn(
"peer data-[state=checked]:bg-primary data-[state=unchecked]:bg-input focus-visible:border-ring focus-visible:ring-ring/50 dark:data-[state=unchecked]:bg-input/80 inline-flex h-[1.15rem] w-8 shrink-0 items-center rounded-full border border-transparent shadow-xs transition-all outline-none focus-visible:ring-[3px] disabled:cursor-not-allowed disabled:opacity-50",
className
'peer data-[state=checked]:bg-primary data-[state=unchecked]:bg-input focus-visible:border-ring focus-visible:ring-ring/50 dark:data-[state=unchecked]:bg-input/80 inline-flex h-[1.15rem] w-8 shrink-0 items-center rounded-full border border-transparent shadow-xs transition-all outline-none focus-visible:ring-[3px] disabled:cursor-not-allowed disabled:opacity-50',
className,
)}
{...props}
>
<SwitchPrimitive.Thumb
data-slot="switch-thumb"
className={cn(
"bg-background dark:data-[state=unchecked]:bg-foreground dark:data-[state=checked]:bg-primary-foreground pointer-events-none block size-4 rounded-full ring-0 transition-transform data-[state=checked]:translate-x-[calc(100%-2px)] data-[state=unchecked]:translate-x-0"
'bg-background dark:data-[state=unchecked]:bg-foreground dark:data-[state=checked]:bg-primary-foreground pointer-events-none block size-4 rounded-full ring-0 transition-transform data-[state=checked]:translate-x-[calc(100%-2px)] data-[state=unchecked]:translate-x-0',
)}
/>
</SwitchPrimitive.Root>
)
);
}
export { Switch }
export { Switch };

96
src/packages/administrativo/components/CCaixaServico/CCaixaServicoSelect.tsx Normal file
View file

@ -0,0 +1,96 @@
'use client';
import React from 'react';
import { Button } from '@/components/ui/button';
import {
Command,
CommandEmpty,
CommandGroup,
CommandInput,
CommandItem,
CommandList,
} from '@/components/ui/command';
import { FormControl } from '@/components/ui/form';
import { Popover, PopoverContent, PopoverTrigger } from '@/components/ui/popover';
import { cn } from '@/lib/utils';
import { CheckIcon, ChevronsUpDownIcon } from 'lucide-react';
import GetCapitalize from '@/shared/actions/text/GetCapitalize';
import { useCCaixaServicoReadHook } from '@/app/(protected)/(cadastros)/cadastros/_hooks/c_caixa_servico/useCCaixaServicoReadHook';
import { CCaixaServicoReadInterface } from '@/app/(protected)/(cadastros)/cadastros/_interfaces/CCaixaServicoReadInterface';
export default function CCaixaServicoSelect({ sistema_id, field }: any) {
const cCaixaServicoReadParams: CCaixaServicoReadInterface = { sistema_id };
const [open, setOpen] = React.useState(false);
const [isLoading, setIsLoading] = React.useState(false);
const { cCaixaServico, fetchCCaixaServico } = useCCaixaServicoReadHook();
// Busca os dados uma única vez ao montar
React.useEffect(() => {
const loadData = async () => {
if (!cCaixaServico.length) {
setIsLoading(true);
await fetchCCaixaServico(cCaixaServicoReadParams);
setIsLoading(false);
}
};
loadData();
}, []);
const selected = cCaixaServico?.find(
(item) => String(item.caixa_servico_id) === String(field.value),
);
return (
<Popover open={open} onOpenChange={setOpen}>
<PopoverTrigger asChild>
<FormControl className="w-full">
<Button
variant="outline"
role="combobox"
aria-expanded={open}
disabled={isLoading}
className="cursor-pointer justify-between"
>
{isLoading
? 'Carregando...'
: selected
? GetCapitalize(selected.descricao)
: 'Selecione o serviço'}
<ChevronsUpDownIcon className="ml-2 h-4 w-4 shrink-0 opacity-50" />
</Button>
</FormControl>
</PopoverTrigger>
<PopoverContent className="w-full p-0">
<Command>
<CommandInput placeholder="Buscar etiquetas/carimbos..." />
<CommandList>
<CommandEmpty>
{isLoading ? 'Carregando...' : 'Nenhum resultado encontrado.'}
</CommandEmpty>
<CommandGroup>
{cCaixaServico?.map((item) => (
<CommandItem
className="cursor-pointer"
key={item.caixa_servico_id}
value={item.descricao?.toLowerCase() ?? ''}
onSelect={() => {
field.onChange(Number(item.caixa_servico_id)); // envia apenas o número
setOpen(false);
}}
>
<CheckIcon
className={cn(
'mr-2 h-4 w-4',
String(field.value) === String(item.caixa_servico_id)
? 'opacity-100'
: 'opacity-0',
)}
/>
{GetCapitalize(item.descricao)}
</CommandItem>
))}
</CommandGroup>
</CommandList>
</Command>
</PopoverContent>
</Popover>
);
}

1
src/packages/administrativo/components/GCidade/GCidadeForm.tsx
View file

@ -35,7 +35,6 @@ import { useGUfReadHook } from '@/packages/administrativo/hooks/GUF/useGUfReadHo
import { GCidadeSchema } from '../../schemas/GCidade/GCidadeSchema';
// Hook responsável em trazer todos os estados brasileiros
// Define o tipo do formulário com base no schema Zod

138
src/packages/administrativo/components/GEmolumento/GEmolumentoSelect.tsx
View file

@ -1,8 +1,10 @@
'use client';
'use client'; // Garante execução no cliente (Next.js App Router)
import { CheckIcon, ChevronsUpDownIcon } from 'lucide-react';
import { useCallback, useEffect, useMemo, useState } from 'react';
import React from 'react';
import { useGEmolumentoReadHook } from '@/app/(protected)/(cadastros)/cadastros/_hooks/g_emolumento/useGEmolumentoReadHook';
import { GEmolumentoReadInterface } from '@/app/(protected)/(cadastros)/cadastros/_interfaces/GEmolumentoReadInterface';
import { Button } from '@/components/ui/button';
import {
Command,
@ -15,56 +17,54 @@ import {
import { FormControl } from '@/components/ui/form';
import { Popover, PopoverContent, PopoverTrigger } from '@/components/ui/popover';
import { cn } from '@/lib/utils';
import { useGEmolumentoIndexHook } from '@/packages/administrativo/hooks/GEmolumento/useGEmolumentoIndexHook';
import GEmolumentoSelectInterface from '@/packages/administrativo/interfaces/GEmolumento/GEmolumentoSelectInterface';
import GetCapitalize from '@/shared/actions/text/GetCapitalize';
export default function GEmolumentoSelect({ field }: GEmolumentoSelectInterface) {
const [open, setOpen] = useState(false);
const [isLoading, setIsLoading] = useState(false);
const { gGramatica = [], indexGEmolumento } = useGEmolumentoIndexHook();
// Tipagem das props do componente
interface GEmolumentoSelectProps {
sistema_id: number; // ID do sistema usado para buscar os emolumentos
field: any; // Objeto de controle do react-hook-form
onSelectChange?: (emolumento: { key: number; value: string }) => void; // Função callback opcional para disparar eventos externos
className?: string; // Classe CSS opcional para customização
}
/**
* Carrega dados apenas uma vez
*/
const loadData = useCallback(async () => {
if (gGramatica.length) return;
setIsLoading(true);
await indexGEmolumento();
setIsLoading(false);
}, [gGramatica.length, indexGEmolumento]);
// Componente principal do select de emolumentos
export default function GEmolumentoSelect({
sistema_id,
field,
onSelectChange,
className,
}: GEmolumentoSelectProps) {
// Define parâmetros de leitura para o hook que busca os emolumentos
const gEmolumentoReadParams: GEmolumentoReadInterface = { sistema_id };
useEffect(() => {
// Estados locais do componente
const [open, setOpen] = React.useState(false); // Controla abertura do popover
const [isLoading, setIsLoading] = React.useState(false); // Exibe “Carregando...” enquanto busca dados
// Hook responsável por buscar emolumentos no backend
const { gEmolumento, fetchGEmolumento } = useGEmolumentoReadHook();
// Carrega os dados de emolumentos apenas uma vez ao montar o componente
React.useEffect(() => {
const loadData = async () => {
if (!gEmolumento.length) {
setIsLoading(true);
await fetchGEmolumento(gEmolumentoReadParams);
setIsLoading(false);
}
};
loadData();
}, [loadData]);
}, []); // ← executa apenas uma vez
/**
* Garante que o valor do campo seja sempre número (ou null)
*/
const value: number | null = field?.value ? Number(field.value) : null;
/**
* Item selecionado (memoizado)
*/
const selected = useMemo(
() => gGramatica.find((b) => Number(b.emolumento_id) === value),
[gGramatica, value],
);
/**
* Manipula a seleção
*/
const handleSelect = useCallback(
(emolumentoId: number) => {
if (!field?.onChange) return;
field.onChange(emolumentoId); // envia como número
setOpen(false);
},
[field],
// Obtém o item selecionado com base no valor atual do campo
const selected = gEmolumento?.find(
(item) => Number(item.emolumento_id) === Number(field.value ?? 0),
);
// Estrutura visual do componente
return (
<Popover open={open} onOpenChange={setOpen}>
{/* === Botão principal (exibe valor selecionado) === */}
<PopoverTrigger asChild>
<FormControl className="w-full">
<Button
@ -72,42 +72,80 @@ export default function GEmolumentoSelect({ field }: GEmolumentoSelectInterface)
role="combobox"
aria-expanded={open}
disabled={isLoading}
className="justify-between"
className={cn(
'min-h-[2.5rem] w-full cursor-pointer justify-between text-left break-words whitespace-normal',
className,
)}
>
{/* Exibe o texto do botão */}
{isLoading
? 'Carregando...'
: selected
? GetCapitalize(selected.descricao)
: 'Selecione...'}
: 'Selecione emolumento'}
{/* Ícone de seta */}
<ChevronsUpDownIcon className="ml-2 h-4 w-4 shrink-0 opacity-50" />
</Button>
</FormControl>
</PopoverTrigger>
<PopoverContent className="w-full p-0">
{/* === Conteúdo do Popover (lista de opções) === */}
<PopoverContent
align="start"
side="bottom"
className="w-[var(--radix-popover-trigger-width)] max-w-full p-0"
>
<Command>
<CommandInput placeholder="Buscar emolumento..." disabled={isLoading} />
{/* Campo de busca dentro do popover */}
<CommandInput placeholder="Buscar emolumentos..." />
<CommandList>
{/* Estado vazio ou carregando */}
<CommandEmpty>
{isLoading ? 'Carregando...' : 'Nenhum resultado encontrado.'}
</CommandEmpty>
{/* Grupo de opções */}
<CommandGroup>
{gGramatica.map((item) => (
{gEmolumento?.map((item) => (
<CommandItem
className="w-full cursor-pointer"
key={item.emolumento_id}
value={item.descricao?.toLowerCase() ?? ''}
onSelect={() => handleSelect(Number(item.emolumento_id))}
// Quando o item é selecionado
onSelect={() => {
// Cria objeto com ID e descrição
const selectedValue = {
key: Number(item.emolumento_id),
value: item.descricao,
};
// Atualiza o valor no react-hook-form com o ID numérico
field.onChange(Number(item.emolumento_id ?? 0));
// Dispara callback externo, se existir (mantém o objeto completo)
if (onSelectChange)
onSelectChange({
key: Number(item.emolumento_id),
value: item.descricao,
});
// Fecha o popover
setOpen(false);
}}
>
{/* Ícone de seleção (check) */}
<CheckIcon
className={cn(
'mr-2 h-4 w-4',
value === Number(item.emolumento_id)
String(field.value?.key ?? field.value) === String(item.emolumento_id)
? 'opacity-100'
: 'opacity-0',
)}
/>
{GetCapitalize(item.descricao ?? '')}
{/* Nome formatado do emolumento */}
{GetCapitalize(item.descricao)}
</CommandItem>
))}
</CommandGroup>

101
src/packages/administrativo/components/GMarcacaoTipo/GMarcacaoTipoSelect.tsx Normal file
View file

@ -0,0 +1,101 @@
'use client';
import React from 'react';
import { Button } from '@/components/ui/button';
import {
Command,
CommandEmpty,
CommandGroup,
CommandInput,
CommandItem,
CommandList,
} from '@/components/ui/command';
import { FormControl } from '@/components/ui/form';
import { Popover, PopoverContent, PopoverTrigger } from '@/components/ui/popover';
import { cn } from '@/lib/utils';
import { CheckIcon, ChevronsUpDownIcon } from 'lucide-react';
import GetCapitalize from '@/shared/actions/text/GetCapitalize';
import { useGMarcacaoTipoReadHook } from '@/app/(protected)/(cadastros)/cadastros/_hooks/g_marcacao_tipo/useGMarcacaoTipoReadHook';
import { GMarcacaoTipoReadInterface } from '@/app/(protected)/(cadastros)/cadastros/_interfaces/GMarcacaoTipoReadInterface';
export default function GMarcacaoTipoSelect({ grupo, sistema_id, situacao, field }: any) {
const gMarcacaoTipoReadParams: GMarcacaoTipoReadInterface = { grupo, sistema_id, situacao };
const [open, setOpen] = React.useState(false);
const [isLoading, setIsLoading] = React.useState(false);
const { gMarcacaoTipo, fetchGMarcacaoTipo } = useGMarcacaoTipoReadHook();
// Busca os dados uma única vez ao montar
React.useEffect(() => {
const loadData = async () => {
if (!gMarcacaoTipo.length) {
setIsLoading(true);
await fetchGMarcacaoTipo(gMarcacaoTipoReadParams);
setIsLoading(false);
}
};
loadData();
}, []);
const selected = gMarcacaoTipo?.find(
(item) => String(item.marcacao_tipo_id) === String(field.value),
);
return (
<Popover open={open} onOpenChange={setOpen}>
<PopoverTrigger asChild>
<FormControl className="w-full">
<Button
variant="outline"
role="combobox"
aria-expanded={open}
disabled={isLoading}
className="cursor-pointer justify-between"
>
{isLoading
? 'Carregando...'
: field.value && typeof field.value === 'object' && field.value.value
? GetCapitalize(field.value.value) // Exibe a descrição do objeto
: field.value && typeof field.value !== 'object'
? field.value // Se for um ID (valor antigo), exibe ele
: 'Selecione a etiqueta/carimbo'}
<ChevronsUpDownIcon className="ml-2 h-4 w-4 shrink-0 opacity-50" />
</Button>
</FormControl>
</PopoverTrigger>
<PopoverContent className="w-full p-0">
<Command>
<CommandInput placeholder="Buscar etiquetas/carimbos..." />
<CommandList>
<CommandEmpty>
{isLoading ? 'Carregando...' : 'Nenhum resultado encontrado.'}
</CommandEmpty>
<CommandGroup>
{gMarcacaoTipo?.map((item) => (
<CommandItem
className="cursor-pointer"
key={item.marcacao_tipo_id}
value={item.descricao?.toLowerCase() ?? ''}
onSelect={() => {
field.onChange({
key: Number(item.marcacao_tipo_id),
value: item.descricao,
});
setOpen(false);
}}
>
<CheckIcon
className={cn(
'mr-2 h-4 w-4',
String(field.value) === String(item.marcacao_tipo_id)
? 'opacity-100'
: 'opacity-0',
)}
/>
{GetCapitalize(item.descricao)}
</CommandItem>
))}
</CommandGroup>
</CommandList>
</Command>
</PopoverContent>
</Popover>
);
}

1
src/packages/administrativo/components/GMedidaTipo/GMedidaTipoIndex.tsx
View file

@ -17,7 +17,6 @@ import { useGMedidaTipoRemoveHook } from '../../hooks/GMedidaTipo/useGMedidaTipo
import { useGMedidaTipoSaveHook } from '../../hooks/GMedidaTipo/useGMedidaTipoSaveHook';
import { GMedidaTipoInterface } from '../../interfaces/GMedidaTipo/GMedidaTipoInterface';
const initialMedidaTipo: GMedidaTipoInterface = {
medida_tipo_id: 0,
sigla: '',

1
src/packages/administrativo/components/GNatureza/GNaturezaIndex.tsx
View file

@ -2,7 +2,6 @@
import { useEffect, useState, useCallback } from 'react';
import { useGNaturezaDeleteHook } from '@/packages/administrativo/hooks/GNatureza/useGNaturezaDeleteHook';
import { useGNaturezaIndexHook } from '@/packages/administrativo/hooks/GNatureza/useGNaturezaIndexHook';
import { useGNaturezaSaveHook } from '@/packages/administrativo/hooks/GNatureza/useGNaturezaSaveHook';

1
src/packages/administrativo/components/GTBBairro/GTBBairroIndex.tsx
View file

@ -17,7 +17,6 @@ import GTBBairroForm from './GTBBairroForm';
import GTBBairroTable from './GTBBairroTable';
import { GTBBairroInterface } from '../../interfaces/GTBBairro/GTBBairroInterface';
const initialBairro: GTBBairroInterface = {
sistema_id: null,
tb_bairro_id: 0,

1
src/packages/administrativo/components/GTBBairro/GTBBairroTable.tsx
View file

@ -23,7 +23,6 @@ import { SituacoesEnum } from '@/shared/enums/SituacoesEnum';
import { GTBBairroInterface } from '../../interfaces/GTBBairro/GTBBairroInterface';
interface GTBBairroTableProps {
data: GTBBairroInterface[];
onEdit: (item: GTBBairroInterface, isEditingFormStatus: boolean) => void;

1
src/packages/administrativo/components/GTBEstadoCivil/GTBEstadoCivilIndex.tsx
View file

@ -16,7 +16,6 @@ import { useGTBEstadoCivilRemoveHook } from '../../hooks/GTBEstadoCivil/useGTBEs
import { useGTBEstadoCivilSaveHook } from '../../hooks/GTBEstadoCivil/useGTBEstadoCivilSaveHook';
import { GTBEstadoCivilInterface } from '../../interfaces/GTBEstadoCivil/GTBEstadoCivilInterface';
const initalEstadoCivil: GTBEstadoCivilInterface = {
tb_estadocivil_id: 0,
sistema_id: 0,

1
src/packages/administrativo/components/GTBRegimeBens/GTBRegimeBensForm.tsx
View file

@ -28,7 +28,6 @@ import { Input } from '@/components/ui/input';
import { Label } from '@/components/ui/label';
import { GTBRegimeBensSchema } from '@/packages/administrativo/schemas/GTBRegimeBens/GTBRegimeBensSchema';
type FormValues = z.infer<typeof GTBRegimeBensSchema>;
interface Props {

1
src/packages/administrativo/components/GTBRegimeComunhao/GTBRegimeComunhaoIndex.tsx
View file

@ -15,7 +15,6 @@ import { useGTBRegimeComunhaoRemoveHook } from '../../hooks/GTBRegimeComunhao/us
import { useGTBRegimeComunhaoSaveHook } from '../../hooks/GTBRegimeComunhao/useGTBRegimeComunhaoSaveHook';
import GTBRegimeComunhaoInterface from '../../interfaces/GTBRegimeComunhao/GTBRegimeComunhaoInterface';
export default function GTBRegimeComunhaoIndex() {
// Hooks para leitura e salvamento
const { gTBRegimeComunhao, fetchGTBRegimeComunhao } = useGTBRegimeComunhaoReadHook();

1
src/packages/administrativo/components/GTBTipoLogradouro/GTBTipoLogradouroIndex.tsx
View file

@ -16,7 +16,6 @@ import { useGTBTipoLogradouroRemoveHook } from '../../hooks/GTBTipoLogradouro/us
import { useGTBTipoLogradouroSaveHook } from '../../hooks/GTBTipoLogradouro/useGTBTipoLogradouroSaveHook';
import { GTBTipoLogradouroInterface } from '../../interfaces/GTBTipoLogradouro/GTBTipoLogradouroInterface';
export default function GTBTipoLogradouroIndex() {
// Controle de exibição de respostas
const { setResponse } = useResponse();

1
src/packages/administrativo/components/TAtoParteTipo/TAtoParteTipoIndex.tsx
View file

@ -2,7 +2,6 @@
import { useEffect, useState, useCallback } from 'react';
import { useTAtoParteTipoDeleteHook } from '@/packages/administrativo/hooks/TAtoParteTipo/useTAtoParteTipoDeleteHook';
import { useTAtoParteTipoIndexHook } from '@/packages/administrativo/hooks/TAtoParteTipo/useTAtoParteTipoIndexHook';
import { useTAtoParteTipoSaveHook } from '@/packages/administrativo/hooks/TAtoParteTipo/useTAtoParteTipoSaveHook';

1
src/packages/administrativo/components/TCensec/TCensecIndex.tsx
View file

@ -15,7 +15,6 @@ import { useTCensecReadHook } from '../../hooks/TCensec/useTCensecReadHook';
import { useTCensecSaveHook } from '../../hooks/TCensec/useTCensecSaveHook';
import TCensecInterface from '../../interfaces/TCensec/TCensecInterface';
export default function TCensecIndex() {
// Controle de estado do botão
const [buttonIsLoading, setButtonIsLoading] = useState(false);

Some files were not shown because too many files have changed in this diff Show more