802 lines
24 KiB
TypeScript
802 lines
24 KiB
TypeScript
import { v } from "convex/values";
|
|
import { mutation, query, internalMutation } from "./_generated/server";
|
|
import { internal } from "./_generated/api";
|
|
import { Id, Doc } from "./_generated/dataModel";
|
|
|
|
// Validador para períodos
|
|
const periodoValidator = v.object({
|
|
dataInicio: v.string(),
|
|
dataFim: v.string(),
|
|
diasCorridos: v.number(),
|
|
});
|
|
|
|
// Helper: Calcular dias entre duas datas
|
|
function calcularDiasEntreDatas(dataInicio: string, dataFim: string): number {
|
|
const inicio = new Date(dataInicio);
|
|
const fim = new Date(dataFim);
|
|
const diffTime = Math.abs(fim.getTime() - inicio.getTime());
|
|
const diffDays = Math.ceil(diffTime / (1000 * 60 * 60 * 24)) + 1;
|
|
return diffDays;
|
|
}
|
|
|
|
// Helper: Agrupar registros de ferias por funcionarioId + anoReferencia
|
|
function agruparPorSolicitacao(
|
|
registros: Array<Doc<"ferias">>
|
|
): Array<{
|
|
funcionarioId: Id<"funcionarios">;
|
|
anoReferencia: number;
|
|
periodos: Array<Doc<"ferias">>;
|
|
status: string;
|
|
observacao?: string;
|
|
motivoReprovacao?: string;
|
|
gestorId?: Id<"usuarios">;
|
|
dataAprovacao?: number;
|
|
dataReprovacao?: number;
|
|
historicoAlteracoes?: Array<{
|
|
data: number;
|
|
usuarioId: Id<"usuarios">;
|
|
acao: string;
|
|
}>;
|
|
}> {
|
|
const grupos = new Map<string, Array<Doc<"ferias">>>();
|
|
|
|
for (const registro of registros) {
|
|
const chave = `${registro.funcionarioId}_${registro.anoReferencia}`;
|
|
if (!grupos.has(chave)) {
|
|
grupos.set(chave, []);
|
|
}
|
|
grupos.get(chave)!.push(registro);
|
|
}
|
|
|
|
return Array.from(grupos.entries()).map(([_, periodos]) => {
|
|
// Ordenar por data de criação para manter ordem
|
|
periodos.sort((a, b) => a._creationTime - b._creationTime);
|
|
|
|
// Pegar informações da primeira solicitação (todos têm os mesmos campos compartilhados)
|
|
const primeiro = periodos[0];
|
|
|
|
return {
|
|
funcionarioId: primeiro.funcionarioId,
|
|
anoReferencia: primeiro.anoReferencia,
|
|
periodos,
|
|
status: primeiro.status,
|
|
observacao: primeiro.observacao,
|
|
motivoReprovacao: primeiro.motivoReprovacao,
|
|
gestorId: primeiro.gestorId,
|
|
dataAprovacao: primeiro.dataAprovacao,
|
|
dataReprovacao: primeiro.dataReprovacao,
|
|
historicoAlteracoes: primeiro.historicoAlteracoes,
|
|
};
|
|
});
|
|
}
|
|
|
|
// Query: Listar TODAS as solicitações (para RH) - períodos individuais
|
|
export const listarTodas = query({
|
|
args: {},
|
|
handler: async (ctx) => {
|
|
const todasFerias = await ctx.db.query("ferias").collect();
|
|
|
|
const periodosComDetalhes = await Promise.all(
|
|
todasFerias.map(async (ferias) => {
|
|
const funcionario = await ctx.db.get(ferias.funcionarioId);
|
|
|
|
// Buscar usuário do funcionário para obter fotoPerfilUrl
|
|
let fotoPerfilUrl: string | null = null;
|
|
if (funcionario) {
|
|
const usuario = await ctx.db
|
|
.query("usuarios")
|
|
.withIndex("by_funcionarioId", (q) => q.eq("funcionarioId", funcionario._id))
|
|
.first();
|
|
if (usuario?.fotoPerfil) {
|
|
fotoPerfilUrl = await ctx.storage.getUrl(usuario.fotoPerfil);
|
|
}
|
|
}
|
|
|
|
// Buscar time do funcionário
|
|
const membroTime = await ctx.db
|
|
.query("timesMembros")
|
|
.withIndex("by_funcionario", (q) =>
|
|
q.eq("funcionarioId", ferias.funcionarioId)
|
|
)
|
|
.filter((q) => q.eq(q.field("ativo"), true))
|
|
.first();
|
|
|
|
let time: Doc<"times"> | null = null;
|
|
let gestor: { _id: Id<"usuarios">; nome: string } | null = null;
|
|
if (membroTime) {
|
|
time = await ctx.db.get(membroTime.timeId);
|
|
// Buscar gestor do time
|
|
if (time?.gestorId) {
|
|
const gestorUsuario = await ctx.db.get(time.gestorId);
|
|
if (gestorUsuario?.funcionarioId) {
|
|
// Buscar funcionário do gestor para obter o nome
|
|
const gestorFuncionario = await ctx.db.get(gestorUsuario.funcionarioId);
|
|
if (gestorFuncionario) {
|
|
gestor = {
|
|
_id: gestorUsuario._id,
|
|
nome: gestorFuncionario.nome,
|
|
};
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return {
|
|
...ferias,
|
|
funcionario: funcionario ? {
|
|
...funcionario,
|
|
fotoPerfilUrl,
|
|
} : null,
|
|
time,
|
|
gestor,
|
|
};
|
|
})
|
|
);
|
|
|
|
return periodosComDetalhes.sort((a, b) => b._creationTime - a._creationTime);
|
|
},
|
|
});
|
|
|
|
// Query: Listar solicitações do funcionário - períodos individuais
|
|
export const listarMinhasSolicitacoes = query({
|
|
args: { funcionarioId: v.id("funcionarios") },
|
|
handler: async (ctx, args) => {
|
|
const todasFerias = await ctx.db
|
|
.query("ferias")
|
|
.withIndex("by_funcionario", (q) =>
|
|
q.eq("funcionarioId", args.funcionarioId)
|
|
)
|
|
.collect();
|
|
|
|
const funcionario = await ctx.db.get(args.funcionarioId);
|
|
|
|
// Buscar time do funcionário
|
|
const membroTime = await ctx.db
|
|
.query("timesMembros")
|
|
.withIndex("by_funcionario", (q) =>
|
|
q.eq("funcionarioId", args.funcionarioId)
|
|
)
|
|
.filter((q) => q.eq(q.field("ativo"), true))
|
|
.first();
|
|
|
|
let time = null;
|
|
if (membroTime) {
|
|
time = await ctx.db.get(membroTime.timeId);
|
|
}
|
|
|
|
// Retornar períodos individuais com detalhes
|
|
return todasFerias.map((ferias) => ({
|
|
...ferias,
|
|
funcionario,
|
|
time,
|
|
})).sort((a, b) => b._creationTime - a._creationTime);
|
|
},
|
|
});
|
|
|
|
// Query: Listar solicitações dos subordinados (para gestores) - períodos individuais
|
|
export const listarSolicitacoesSubordinados = query({
|
|
args: { gestorId: v.id("usuarios") },
|
|
handler: async (ctx, args) => {
|
|
// Buscar times onde o usuário é gestor
|
|
const timesGestor = await ctx.db
|
|
.query("times")
|
|
.withIndex("by_gestor", (q) => q.eq("gestorId", args.gestorId))
|
|
.filter((q) => q.eq(q.field("ativo"), true))
|
|
.collect();
|
|
|
|
const todasFerias: Array<Doc<"ferias">> = [];
|
|
|
|
for (const time of timesGestor) {
|
|
// Buscar membros do time
|
|
const membros = await ctx.db
|
|
.query("timesMembros")
|
|
.withIndex("by_time_and_ativo", (q) =>
|
|
q.eq("timeId", time._id).eq("ativo", true)
|
|
)
|
|
.collect();
|
|
|
|
// Buscar férias de cada membro
|
|
for (const membro of membros) {
|
|
const ferias = await ctx.db
|
|
.query("ferias")
|
|
.withIndex("by_funcionario", (q) =>
|
|
q.eq("funcionarioId", membro.funcionarioId)
|
|
)
|
|
.collect();
|
|
|
|
todasFerias.push(...ferias);
|
|
}
|
|
}
|
|
|
|
// Adicionar info do funcionário e time para cada período
|
|
const periodosComDetalhes = await Promise.all(
|
|
todasFerias.map(async (ferias) => {
|
|
const funcionario = await ctx.db.get(ferias.funcionarioId);
|
|
|
|
// Buscar time do funcionário
|
|
const membroTime = await ctx.db
|
|
.query("timesMembros")
|
|
.withIndex("by_funcionario", (q) =>
|
|
q.eq("funcionarioId", ferias.funcionarioId)
|
|
)
|
|
.filter((q) => q.eq(q.field("ativo"), true))
|
|
.first();
|
|
|
|
let time = null;
|
|
if (membroTime) {
|
|
time = await ctx.db.get(membroTime.timeId);
|
|
}
|
|
|
|
return {
|
|
...ferias,
|
|
funcionario,
|
|
time,
|
|
};
|
|
})
|
|
);
|
|
|
|
return periodosComDetalhes.sort((a, b) => b._creationTime - a._creationTime);
|
|
},
|
|
});
|
|
|
|
// Query: Obter detalhes de um período individual
|
|
export const obterDetalhes = query({
|
|
args: {
|
|
feriasId: v.id("ferias")
|
|
},
|
|
handler: async (ctx, args) => {
|
|
const ferias = await ctx.db.get(args.feriasId);
|
|
|
|
if (!ferias) return null;
|
|
|
|
const funcionario = await ctx.db.get(ferias.funcionarioId);
|
|
let gestor = null;
|
|
if (ferias.gestorId) {
|
|
gestor = await ctx.db.get(ferias.gestorId);
|
|
}
|
|
|
|
// Buscar time do funcionário
|
|
const membroTime = await ctx.db
|
|
.query("timesMembros")
|
|
.withIndex("by_funcionario", (q) =>
|
|
q.eq("funcionarioId", ferias.funcionarioId)
|
|
)
|
|
.filter((q) => q.eq(q.field("ativo"), true))
|
|
.first();
|
|
|
|
let time = null;
|
|
if (membroTime) {
|
|
time = await ctx.db.get(membroTime.timeId);
|
|
}
|
|
|
|
return {
|
|
...ferias,
|
|
funcionario,
|
|
gestor,
|
|
time,
|
|
};
|
|
},
|
|
});
|
|
|
|
// Mutation: Criar solicitação de férias (cria um registro por período)
|
|
export const criarSolicitacao = mutation({
|
|
args: {
|
|
funcionarioId: v.id("funcionarios"),
|
|
anoReferencia: v.number(),
|
|
periodos: v.array(periodoValidator),
|
|
observacao: v.optional(v.string()),
|
|
},
|
|
returns: v.array(v.id("ferias")),
|
|
handler: async (ctx, args) => {
|
|
if (args.periodos.length === 0) {
|
|
throw new Error("É necessário adicionar pelo menos 1 período");
|
|
}
|
|
|
|
const funcionario = await ctx.db.get(args.funcionarioId);
|
|
if (!funcionario) throw new Error("Funcionário não encontrado");
|
|
|
|
// Buscar usuário que está criando (pode não ser o próprio funcionário)
|
|
const usuario = await ctx.db
|
|
.query("usuarios")
|
|
.withIndex("by_funcionarioId", (q) =>
|
|
q.eq("funcionarioId", args.funcionarioId)
|
|
)
|
|
.first();
|
|
|
|
const historicoInicial = [
|
|
{
|
|
data: Date.now(),
|
|
usuarioId: usuario?._id || funcionario.gestorId!,
|
|
acao: "Solicitação criada",
|
|
},
|
|
];
|
|
|
|
// Criar um registro para cada período
|
|
const idsCriados: Array<Id<"ferias">> = [];
|
|
for (const periodo of args.periodos) {
|
|
const feriasId = await ctx.db.insert("ferias", {
|
|
funcionarioId: args.funcionarioId,
|
|
anoReferencia: args.anoReferencia,
|
|
dataInicio: periodo.dataInicio,
|
|
dataFim: periodo.dataFim,
|
|
diasFerias: periodo.diasCorridos,
|
|
status: "aguardando_aprovacao",
|
|
observacao: args.observacao,
|
|
diasAbono: 0,
|
|
historicoAlteracoes: historicoInicial,
|
|
});
|
|
idsCriados.push(feriasId);
|
|
}
|
|
|
|
// Notificar gestor (usar o primeiro ID criado)
|
|
if (funcionario.gestorId && idsCriados.length > 0) {
|
|
await ctx.db.insert("notificacoesFerias", {
|
|
destinatarioId: funcionario.gestorId,
|
|
feriasId: idsCriados[0],
|
|
tipo: "nova_solicitacao",
|
|
lida: false,
|
|
mensagem: `${funcionario.nome} solicitou férias`,
|
|
});
|
|
}
|
|
|
|
return idsCriados;
|
|
},
|
|
});
|
|
|
|
// Mutation: Aprovar período de férias individual
|
|
export const aprovar = mutation({
|
|
args: {
|
|
feriasId: v.id("ferias"),
|
|
gestorId: v.id("usuarios"),
|
|
},
|
|
returns: v.null(),
|
|
handler: async (ctx, args) => {
|
|
// Buscar o registro específico
|
|
const registro = await ctx.db.get(args.feriasId);
|
|
|
|
if (!registro) {
|
|
throw new Error("Período de férias não encontrado");
|
|
}
|
|
|
|
// Verificar se está aguardando aprovação
|
|
if (registro.status !== "aguardando_aprovacao") {
|
|
throw new Error("Este período já foi processado");
|
|
}
|
|
|
|
const funcionario = await ctx.db.get(registro.funcionarioId);
|
|
|
|
// Atualizar o registro
|
|
await ctx.db.patch(registro._id, {
|
|
status: "aprovado",
|
|
gestorId: args.gestorId,
|
|
dataAprovacao: Date.now(),
|
|
historicoAlteracoes: [
|
|
...(registro.historicoAlteracoes || []),
|
|
{
|
|
data: Date.now(),
|
|
usuarioId: args.gestorId,
|
|
acao: "Aprovado",
|
|
},
|
|
],
|
|
});
|
|
|
|
// Notificar funcionário
|
|
if (funcionario) {
|
|
const usuario = await ctx.db
|
|
.query("usuarios")
|
|
.withIndex("by_funcionarioId", (q) =>
|
|
q.eq("funcionarioId", funcionario._id)
|
|
)
|
|
.first();
|
|
|
|
if (usuario) {
|
|
await ctx.db.insert("notificacoesFerias", {
|
|
destinatarioId: usuario._id,
|
|
feriasId: registro._id,
|
|
tipo: "aprovado",
|
|
lida: false,
|
|
mensagem: `Período de férias de ${registro.diasFerias} dias foi aprovado!`,
|
|
});
|
|
}
|
|
}
|
|
|
|
return null;
|
|
},
|
|
});
|
|
|
|
// Mutation: Reprovar período de férias individual
|
|
export const reprovar = mutation({
|
|
args: {
|
|
feriasId: v.id("ferias"),
|
|
gestorId: v.id("usuarios"),
|
|
motivoReprovacao: v.string(),
|
|
},
|
|
returns: v.null(),
|
|
handler: async (ctx, args) => {
|
|
// Buscar o registro específico
|
|
const registro = await ctx.db.get(args.feriasId);
|
|
|
|
if (!registro) {
|
|
throw new Error("Período de férias não encontrado");
|
|
}
|
|
|
|
// Verificar se está aguardando aprovação
|
|
if (registro.status !== "aguardando_aprovacao") {
|
|
throw new Error("Este período já foi processado");
|
|
}
|
|
|
|
const funcionario = await ctx.db.get(registro.funcionarioId);
|
|
|
|
// Atualizar o registro
|
|
await ctx.db.patch(registro._id, {
|
|
status: "reprovado",
|
|
gestorId: args.gestorId,
|
|
dataReprovacao: Date.now(),
|
|
motivoReprovacao: args.motivoReprovacao,
|
|
historicoAlteracoes: [
|
|
...(registro.historicoAlteracoes || []),
|
|
{
|
|
data: Date.now(),
|
|
usuarioId: args.gestorId,
|
|
acao: `Reprovado: ${args.motivoReprovacao}`,
|
|
},
|
|
],
|
|
});
|
|
|
|
// Notificar funcionário
|
|
if (funcionario) {
|
|
const usuario = await ctx.db
|
|
.query("usuarios")
|
|
.withIndex("by_funcionarioId", (q) =>
|
|
q.eq("funcionarioId", funcionario._id)
|
|
)
|
|
.first();
|
|
|
|
if (usuario) {
|
|
await ctx.db.insert("notificacoesFerias", {
|
|
destinatarioId: usuario._id,
|
|
feriasId: registro._id,
|
|
tipo: "reprovado",
|
|
lida: false,
|
|
mensagem: `Período de férias de ${registro.diasFerias} dias foi reprovado: ${args.motivoReprovacao}`,
|
|
});
|
|
}
|
|
}
|
|
|
|
return null;
|
|
},
|
|
});
|
|
|
|
// Mutation: Ajustar data e aprovar período individual
|
|
export const ajustarEAprovar = mutation({
|
|
args: {
|
|
feriasId: v.id("ferias"),
|
|
gestorId: v.id("usuarios"),
|
|
novaDataInicio: v.string(),
|
|
novaDataFim: v.string(),
|
|
},
|
|
returns: v.null(),
|
|
handler: async (ctx, args) => {
|
|
// Buscar o registro específico
|
|
const registroAntigo = await ctx.db.get(args.feriasId);
|
|
|
|
if (!registroAntigo) {
|
|
throw new Error("Período de férias não encontrado");
|
|
}
|
|
|
|
// Verificar se está aguardando aprovação
|
|
if (registroAntigo.status !== "aguardando_aprovacao") {
|
|
throw new Error("Este período já foi processado");
|
|
}
|
|
|
|
const funcionario = await ctx.db.get(registroAntigo.funcionarioId);
|
|
|
|
// Calcular novos dias
|
|
const novosDias = calcularDiasEntreDatas(args.novaDataInicio, args.novaDataFim);
|
|
|
|
// Atualizar o registro com novas datas
|
|
await ctx.db.patch(registroAntigo._id, {
|
|
dataInicio: args.novaDataInicio,
|
|
dataFim: args.novaDataFim,
|
|
diasFerias: novosDias,
|
|
status: "data_ajustada_aprovada",
|
|
gestorId: args.gestorId,
|
|
dataAprovacao: Date.now(),
|
|
historicoAlteracoes: [
|
|
...(registroAntigo.historicoAlteracoes || []),
|
|
{
|
|
data: Date.now(),
|
|
usuarioId: args.gestorId,
|
|
acao: `Data ajustada e aprovada: ${registroAntigo.dataInicio} - ${registroAntigo.dataFim} → ${args.novaDataInicio} - ${args.novaDataFim}`,
|
|
},
|
|
],
|
|
});
|
|
|
|
// Notificar funcionário
|
|
if (funcionario) {
|
|
const usuario = await ctx.db
|
|
.query("usuarios")
|
|
.withIndex("by_funcionarioId", (q) =>
|
|
q.eq("funcionarioId", funcionario._id)
|
|
)
|
|
.first();
|
|
|
|
if (usuario) {
|
|
await ctx.db.insert("notificacoesFerias", {
|
|
destinatarioId: usuario._id,
|
|
feriasId: registroAntigo._id,
|
|
tipo: "data_ajustada",
|
|
lida: false,
|
|
mensagem: `Período de férias foi aprovado com ajuste de datas: ${args.novaDataInicio} a ${args.novaDataFim}`,
|
|
});
|
|
}
|
|
}
|
|
|
|
return null;
|
|
},
|
|
});
|
|
|
|
// Query: Verificar status de férias automático
|
|
export const verificarStatusFerias = query({
|
|
args: { funcionarioId: v.id("funcionarios") },
|
|
returns: v.union(v.literal("ativo"), v.literal("em_ferias")),
|
|
handler: async (ctx, args) => {
|
|
const hoje = new Date();
|
|
hoje.setHours(0, 0, 0, 0);
|
|
|
|
const feriasAprovadas = await ctx.db
|
|
.query("ferias")
|
|
.withIndex("by_funcionario_and_status", (q) =>
|
|
q.eq("funcionarioId", args.funcionarioId).eq("status", "aprovado")
|
|
)
|
|
.collect();
|
|
|
|
const feriasAjustadas = await ctx.db
|
|
.query("ferias")
|
|
.withIndex("by_funcionario_and_status", (q) =>
|
|
q
|
|
.eq("funcionarioId", args.funcionarioId)
|
|
.eq("status", "data_ajustada_aprovada")
|
|
)
|
|
.collect();
|
|
|
|
const feriasEmFerias = await ctx.db
|
|
.query("ferias")
|
|
.withIndex("by_funcionario_and_status", (q) =>
|
|
q.eq("funcionarioId", args.funcionarioId).eq("status", "EmFérias")
|
|
)
|
|
.collect();
|
|
|
|
const todasFerias = [
|
|
...feriasAprovadas,
|
|
...feriasAjustadas,
|
|
...feriasEmFerias,
|
|
];
|
|
|
|
for (const ferias of todasFerias) {
|
|
const inicio = new Date(ferias.dataInicio);
|
|
const fim = new Date(ferias.dataFim);
|
|
inicio.setHours(0, 0, 0, 0);
|
|
fim.setHours(23, 59, 59, 999);
|
|
|
|
if (hoje >= inicio && hoje <= fim) {
|
|
return "em_ferias";
|
|
}
|
|
}
|
|
|
|
return "ativo";
|
|
},
|
|
});
|
|
|
|
// Query: Obter notificações não lidas
|
|
export const obterNotificacoesNaoLidas = query({
|
|
args: { usuarioId: v.id("usuarios") },
|
|
handler: async (ctx, args) => {
|
|
return await ctx.db
|
|
.query("notificacoesFerias")
|
|
.withIndex("by_destinatario_and_lida", (q) =>
|
|
q.eq("destinatarioId", args.usuarioId).eq("lida", false)
|
|
)
|
|
.collect();
|
|
},
|
|
});
|
|
|
|
// Mutation: Marcar notificação como lida
|
|
export const marcarComoLida = mutation({
|
|
args: { notificacaoId: v.id("notificacoesFerias") },
|
|
returns: v.null(),
|
|
handler: async (ctx, args) => {
|
|
await ctx.db.patch(args.notificacaoId, { lida: true });
|
|
return null;
|
|
},
|
|
});
|
|
|
|
// Mutation: Atualizar status de um período individual
|
|
export const atualizarStatus = mutation({
|
|
args: {
|
|
feriasId: v.id("ferias"),
|
|
novoStatus: v.union(
|
|
v.literal("aguardando_aprovacao"),
|
|
v.literal("aprovado"),
|
|
v.literal("reprovado"),
|
|
v.literal("data_ajustada_aprovada"),
|
|
v.literal("Cancelado_RH")
|
|
),
|
|
usuarioId: v.id("usuarios"),
|
|
},
|
|
returns: v.null(),
|
|
handler: async (ctx, args) => {
|
|
// Buscar o registro específico
|
|
const registro = await ctx.db.get(args.feriasId);
|
|
|
|
if (!registro) {
|
|
throw new Error("Período de férias não encontrado");
|
|
}
|
|
|
|
// Atualizar status e histórico
|
|
const acao = `Status alterado para ${args.novoStatus}`;
|
|
|
|
const updateData: {
|
|
status: typeof args.novoStatus;
|
|
historicoAlteracoes: Array<{
|
|
data: number;
|
|
usuarioId: Id<"usuarios">;
|
|
acao: string;
|
|
}>;
|
|
gestorId?: undefined;
|
|
dataAprovacao?: undefined;
|
|
dataReprovacao?: undefined;
|
|
motivoReprovacao?: undefined;
|
|
} = {
|
|
status: args.novoStatus,
|
|
historicoAlteracoes: [
|
|
...(registro.historicoAlteracoes || []),
|
|
{
|
|
data: Date.now(),
|
|
usuarioId: args.usuarioId,
|
|
acao,
|
|
},
|
|
],
|
|
};
|
|
|
|
// Se voltar para aguardando_aprovacao, limpar campos relacionados
|
|
if (args.novoStatus === "aguardando_aprovacao") {
|
|
await ctx.db.patch(registro._id, {
|
|
...updateData,
|
|
gestorId: undefined,
|
|
dataAprovacao: undefined,
|
|
dataReprovacao: undefined,
|
|
motivoReprovacao: undefined,
|
|
});
|
|
} else {
|
|
await ctx.db.patch(registro._id, updateData);
|
|
}
|
|
|
|
return null;
|
|
},
|
|
});
|
|
|
|
// Internal Mutation: Atualizar status de todos os funcionários
|
|
export const atualizarStatusTodosFuncionarios = internalMutation({
|
|
args: {},
|
|
returns: v.null(),
|
|
handler: async (ctx) => {
|
|
const funcionarios = await ctx.db.query("funcionarios").collect();
|
|
|
|
for (const func of funcionarios) {
|
|
const hoje = new Date();
|
|
hoje.setHours(0, 0, 0, 0);
|
|
|
|
// Buscar todos os registros de férias que podem estar em férias
|
|
// Buscar por status específico para criar mapas de referência
|
|
const feriasAprovadas = await ctx.db
|
|
.query("ferias")
|
|
.withIndex("by_funcionario_and_status", (q) =>
|
|
q.eq("funcionarioId", func._id).eq("status", "aprovado")
|
|
)
|
|
.collect();
|
|
|
|
const feriasAjustadas = await ctx.db
|
|
.query("ferias")
|
|
.withIndex("by_funcionario_and_status", (q) =>
|
|
q.eq("funcionarioId", func._id).eq("status", "data_ajustada_aprovada")
|
|
)
|
|
.collect();
|
|
|
|
const feriasEmFerias = await ctx.db
|
|
.query("ferias")
|
|
.withIndex("by_funcionario_and_status", (q) =>
|
|
q.eq("funcionarioId", func._id).eq("status", "EmFérias")
|
|
)
|
|
.collect();
|
|
|
|
// Criar mapas para verificar status original
|
|
// Quando um registro está "EmFérias", precisamos saber qual era o status anterior
|
|
// Vamos usar o histórico ou verificar se o ID estava nas listas antes
|
|
const idsAprovados = new Set(feriasAprovadas.map(f => f._id));
|
|
const idsAjustados = new Set(feriasAjustadas.map(f => f._id));
|
|
|
|
// Para registros que estão "EmFérias", verificar o histórico para determinar status anterior
|
|
// Se não houver histórico claro, usar lógica: se foi aprovado recentemente, provavelmente era "aprovado"
|
|
// Por enquanto, vamos usar uma heurística: se o registro está "EmFérias" e não está nas listas,
|
|
// vamos verificar o histórico de alterações para encontrar o status anterior
|
|
const statusAnteriorPorId = new Map<Id<"ferias">, "aprovado" | "data_ajustada_aprovada">();
|
|
|
|
for (const ferias of feriasEmFerias) {
|
|
// Verificar histórico para encontrar status anterior
|
|
if (ferias.historicoAlteracoes && ferias.historicoAlteracoes.length > 0) {
|
|
// Procurar pela última alteração que mudou para "EmFérias" ou antes disso
|
|
const historico = ferias.historicoAlteracoes;
|
|
for (let i = historico.length - 1; i >= 0; i--) {
|
|
const entrada = historico[i];
|
|
if (entrada.acao.includes("Aprovado") || entrada.acao.includes("aprovado")) {
|
|
statusAnteriorPorId.set(ferias._id, "aprovado");
|
|
break;
|
|
} else if (entrada.acao.includes("Data ajustada") || entrada.acao.includes("ajustada")) {
|
|
statusAnteriorPorId.set(ferias._id, "data_ajustada_aprovada");
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
// Se não encontrou no histórico, usar fallback: assumir "aprovado"
|
|
if (!statusAnteriorPorId.has(ferias._id)) {
|
|
statusAnteriorPorId.set(ferias._id, "aprovado");
|
|
}
|
|
}
|
|
|
|
// Combinar todos os registros
|
|
const todasFerias = [
|
|
...feriasAprovadas,
|
|
...feriasAjustadas,
|
|
...feriasEmFerias,
|
|
];
|
|
|
|
let emFerias = false;
|
|
for (const ferias of todasFerias) {
|
|
const inicio = new Date(ferias.dataInicio);
|
|
const fim = new Date(ferias.dataFim);
|
|
inicio.setHours(0, 0, 0, 0);
|
|
fim.setHours(23, 59, 59, 999);
|
|
|
|
if (hoje >= inicio && hoje <= fim) {
|
|
emFerias = true;
|
|
|
|
// Atualizar status para "EmFérias" se ainda não estiver
|
|
if (ferias.status !== "EmFérias") {
|
|
await ctx.db.patch(ferias._id, {
|
|
status: "EmFérias",
|
|
});
|
|
}
|
|
} else {
|
|
// Se saiu do período e está "EmFérias", voltar para o status anterior
|
|
if (ferias.status === "EmFérias") {
|
|
// Determinar status anterior
|
|
let statusAnterior: "aprovado" | "data_ajustada_aprovada";
|
|
|
|
if (idsAprovados.has(ferias._id)) {
|
|
statusAnterior = "aprovado";
|
|
} else if (idsAjustados.has(ferias._id)) {
|
|
statusAnterior = "data_ajustada_aprovada";
|
|
} else {
|
|
// Usar histórico ou fallback
|
|
statusAnterior = statusAnteriorPorId.get(ferias._id) || "aprovado";
|
|
}
|
|
|
|
await ctx.db.patch(ferias._id, {
|
|
status: statusAnterior,
|
|
});
|
|
}
|
|
}
|
|
}
|
|
|
|
const novoStatus = emFerias ? "em_ferias" : "ativo";
|
|
|
|
if (func.statusFerias !== novoStatus) {
|
|
await ctx.db.patch(func._id, { statusFerias: novoStatus });
|
|
}
|
|
}
|
|
|
|
return null;
|
|
},
|
|
});
|