refactor: enhance licitacoes page layout and add contratos permissions

- Improved the layout of the licitacoes page for better readability and user experience.
- Added new permissions for contratos, including listar, criar, editar, excluir, and ver actions.
- Introduced a new schema for contratos with relevant fields and indexes to support contract management.

packages/backend/convex/_generated/api.d.ts

@@ -21,6 +21,7 @@ import type * as auth_utils from "../auth/utils.js";
 import type * as chamados from "../chamados.js";
 import type * as chat from "../chat.js";
 import type * as configuracaoEmail from "../configuracaoEmail.js";
+import type * as contratos from "../contratos.js";
 import type * as crons from "../crons.js";
 import type * as cursos from "../cursos.js";
 import type * as dashboard from "../dashboard.js";
@@ -71,6 +72,7 @@ declare const fullApi: ApiFromModules<{
   chamados: typeof chamados;
   chat: typeof chat;
   configuracaoEmail: typeof configuracaoEmail;
+  contratos: typeof contratos;
   crons: typeof crons;
   cursos: typeof cursos;
   dashboard: typeof dashboard;

packages/backend/convex/contratos.ts

@@ -0,0 +1,200 @@
+import { mutation, query } from "./_generated/server";
+import { v } from "convex/values";
+import { situacaoContrato } from "./schema";
+import { getCurrentUserFunction } from "./auth";
+import { internal } from "./_generated/api";
+
+export const listar = query({
+  args: {
+    responsavelId: v.optional(v.id("funcionarios")),
+    dataInicio: v.optional(v.string()),
+    dataFim: v.optional(v.string()),
+  },
+  handler: async (ctx, args) => {
+    await ctx.runQuery(internal.permissoesAcoes.assertPermissaoAcaoAtual, {
+      recurso: "contratos",
+      acao: "listar",
+    });
+
+    let q = ctx.db.query("contratos");
+
+    if (args.responsavelId) {
+      q = q.withIndex("by_responsavel", (q) =>
+        q.eq("responsavelId", args.responsavelId!)
+      ) as typeof q;
+    }
+
+    const contratos = await q.collect();
+
+    // Filtros em memória para datas (já que Convex não tem filtro de range nativo eficiente combinado com outros índices sem setup complexo)
+    // Se o volume for muito grande, ideal seria criar índices específicos ou usar search.
+    let resultado = contratos;
+
+    if (args.dataInicio) {
+      resultado = resultado.filter(
+        (c) => c.dataInicioVigencia >= args.dataInicio!
+      );
+    }
+
+    if (args.dataFim) {
+      resultado = resultado.filter((c) => c.dataFimVigencia <= args.dataFim!);
+    }
+
+    // Enriquecer com dados relacionados
+    const contratosEnriquecidos = await Promise.all(
+      resultado.map(async (c) => {
+        const contratada = await ctx.db.get(c.contratadaId);
+        const responsavel = await ctx.db.get(c.responsavelId);
+        return {
+          ...c,
+          contratada,
+          responsavel,
+        };
+      })
+    );
+
+    return contratosEnriquecidos;
+  },
+});
+
+export const obter = query({
+  args: { id: v.id("contratos") },
+  handler: async (ctx, args) => {
+    await ctx.runQuery(internal.permissoesAcoes.assertPermissaoAcaoAtual, {
+      recurso: "contratos",
+      acao: "ver",
+    });
+    const contrato = await ctx.db.get(args.id);
+    if (!contrato) return null;
+
+    const contratada = await ctx.db.get(contrato.contratadaId);
+    const responsavel = await ctx.db.get(contrato.responsavelId);
+
+    return {
+      ...contrato,
+      contratada,
+      responsavel,
+    };
+  },
+});
+
+export const criar = mutation({
+  args: {
+    contratadaId: v.id("empresas"),
+    objeto: v.string(),
+    numeroNotaEmpenho: v.string(),
+    responsavelId: v.id("funcionarios"),
+    departamento: v.string(),
+    situacao: situacaoContrato,
+    numeroProcessoLicitatorio: v.string(),
+    modalidade: v.string(),
+    numeroContrato: v.string(),
+    anoContrato: v.number(),
+    dataInicioVigencia: v.string(),
+    dataFimVigencia: v.string(),
+    nomeFiscal: v.string(),
+    valorTotal: v.string(),
+    dataAditivoPrazo: v.optional(v.string()),
+    diasAvisoVencimento: v.number(),
+  },
+  handler: async (ctx, args) => {
+    await ctx.runQuery(internal.permissoesAcoes.assertPermissaoAcaoAtual, {
+      recurso: "contratos",
+      acao: "criar",
+    });
+
+    const usuario = await getCurrentUserFunction(ctx);
+    if (!usuario) throw new Error("Não autenticado");
+
+    const id = await ctx.db.insert("contratos", {
+      ...args,
+      criadoPor: usuario._id,
+      criadoEm: Date.now(),
+    });
+
+    return id;
+  },
+});
+
+export const editar = mutation({
+  args: {
+    id: v.id("contratos"),
+    contratadaId: v.optional(v.id("empresas")),
+    objeto: v.optional(v.string()),
+    numeroNotaEmpenho: v.optional(v.string()),
+    responsavelId: v.optional(v.id("funcionarios")),
+    departamento: v.optional(v.string()),
+    situacao: v.optional(situacaoContrato),
+    numeroProcessoLicitatorio: v.optional(v.string()),
+    modalidade: v.optional(v.string()),
+    numeroContrato: v.optional(v.string()),
+    anoContrato: v.optional(v.number()),
+    dataInicioVigencia: v.optional(v.string()),
+    dataFimVigencia: v.optional(v.string()),
+    nomeFiscal: v.optional(v.string()),
+    valorTotal: v.optional(v.string()),
+    dataAditivoPrazo: v.optional(v.string()),
+    diasAvisoVencimento: v.optional(v.number()),
+  },
+  handler: async (ctx, args) => {
+    await ctx.runQuery(internal.permissoesAcoes.assertPermissaoAcaoAtual, {
+      recurso: "contratos",
+      acao: "editar",
+    });
+
+    const { id, ...campos } = args;
+
+    await ctx.db.patch(id, {
+      ...campos,
+      atualizadoEm: Date.now(),
+    });
+  },
+});
+
+export const excluir = mutation({
+  args: { id: v.id("contratos") },
+  handler: async (ctx, args) => {
+    await ctx.runQuery(internal.permissoesAcoes.assertPermissaoAcaoAtual, {
+      recurso: "contratos",
+      acao: "excluir",
+    });
+    await ctx.db.delete(args.id);
+  },
+});
+
+export const verificarVencimentos = query({
+  args: {},
+  handler: async (ctx) => {
+    // Esta query pode ser usada por um componente de notificação ou cron job
+    // Retorna contratos que estão próximos do vencimento baseados no diasAvisoVencimento
+
+    const hoje = new Date();
+    const hojeStr = hoje.toISOString().split("T")[0];
+
+    // Buscar contratos ativos (em execução ou aguardando assinatura)
+    const contratos = await ctx.db
+      .query("contratos")
+      .filter((q) =>
+        q.or(
+          q.eq(q.field("situacao"), "em_execucao"),
+          q.eq(q.field("situacao"), "aguardando_assinatura")
+        )
+      )
+      .collect();
+
+    const proximosVencimento = contratos.filter((c) => {
+      if (!c.dataFimVigencia) return false;
+
+      const dataFim = new Date(c.dataFimVigencia);
+      const dataAviso = new Date(dataFim);
+      dataAviso.setDate(dataAviso.getDate() - c.diasAvisoVencimento);
+
+      const dataAvisoStr = dataAviso.toISOString().split("T")[0];
+
+      // Se hoje for maior ou igual a data de aviso e menor que a data fim
+      return hojeStr >= dataAvisoStr && hojeStr <= c.dataFimVigencia;
+    });
+
+    return proximosVencimento;
+  },
+});

packages/backend/convex/permissoesAcoes.ts

@@ -224,6 +224,36 @@ const PERMISSOES_BASE = {
 			acao: 'ver',
 			descricao: 'Acessar telas do módulo de licitações'
 		},
+		{
+			nome: 'contratos.listar',
+			recurso: 'contratos',
+			acao: 'listar',
+			descricao: 'Listar contratos'
+		},
+		{
+			nome: 'contratos.criar',
+			recurso: 'contratos',
+			acao: 'criar',
+			descricao: 'Criar novos contratos'
+		},
+		{
+			nome: 'contratos.editar',
+			recurso: 'contratos',
+			acao: 'editar',
+			descricao: 'Editar contratos'
+		},
+		{
+			nome: 'contratos.excluir',
+			recurso: 'contratos',
+			acao: 'excluir',
+			descricao: 'Excluir contratos'
+		},
+		{
+			nome: 'contratos.ver',
+			recurso: 'contratos',
+			acao: 'ver',
+			descricao: 'Visualizar detalhes de contratos'
+		},
 		// Compras
 		{
 			nome: 'compras.ver',

packages/backend/convex/schema.ts

@@ -120,7 +120,40 @@ export const reportStatus = v.union(
   v.literal("falhou")
 );
 
+export const situacaoContrato = v.union(
+  v.literal("em_execucao"),
+  v.literal("rescendido"),
+  v.literal("aguardando_assinatura"),
+  v.literal("finalizado")
+);
+
 export default defineSchema({
+  contratos: defineTable({
+    contratadaId: v.id("empresas"),
+    objeto: v.string(),
+    numeroNotaEmpenho: v.string(),
+    responsavelId: v.id("funcionarios"),
+    departamento: v.string(),
+    situacao: situacaoContrato,
+    numeroProcessoLicitatorio: v.string(),
+    modalidade: v.string(),
+    numeroContrato: v.string(),
+    anoContrato: v.number(),
+    dataInicioVigencia: v.string(),
+    dataFimVigencia: v.string(),
+    nomeFiscal: v.string(),
+    valorTotal: v.string(),
+    dataAditivoPrazo: v.optional(v.string()),
+    diasAvisoVencimento: v.number(),
+    criadoPor: v.id("usuarios"),
+    criadoEm: v.number(),
+    atualizadoEm: v.optional(v.number()),
+  })
+    .index("by_responsavel", ["responsavelId"])
+    .index("by_situacao", ["situacao"])
+    .index("by_vigencia_inicio", ["dataInicioVigencia"])
+    .index("by_vigencia_fim", ["dataFimVigencia"]),
+
   todos: defineTable({
     text: v.string(),
     completed: v.boolean(),