481 lines
15 KiB
TypeScript
481 lines
15 KiB
TypeScript
import { v } from 'convex/values';
|
|
import type { Id } from './_generated/dataModel';
|
|
import type { QueryCtx } from './_generated/server';
|
|
import { query } from './_generated/server';
|
|
|
|
/**
|
|
* SISTEMA DE CÁLCULO DE SALDO DE FÉRIAS
|
|
* Suporte a múltiplos regimes de trabalho
|
|
*
|
|
* ============================================
|
|
* REGRAS CLT (Consolidação das Leis do Trabalho):
|
|
* ============================================
|
|
* - 30 dias de férias por ano trabalhado
|
|
* - Período aquisitivo: 12 meses de trabalho
|
|
* - Período concessivo: 12 meses após aquisitivo
|
|
* - Pode dividir em até 3 períodos
|
|
* - Um período deve ter no mínimo 14 dias
|
|
* - Demais períodos: mínimo 5 dias cada
|
|
* - Abono pecuniário: vender 1/3 das férias (10 dias) - OPCIONAL
|
|
*
|
|
* ============================================
|
|
* REGRAS SERVIDOR PÚBLICO ESTADUAL DE PERNAMBUCO
|
|
* Lei nº 6.123/1968 - Estatuto dos Funcionários Públicos Civis do Estado de PE
|
|
* ============================================
|
|
* - 30 dias de férias por ano de exercício
|
|
* - Pode dividir em até 2 períodos (NÃO 3)
|
|
* - Nenhum período pode ser inferior a 10 dias (NÃO 5)
|
|
* - NÃO permite abono pecuniário (venda de férias)
|
|
* - Férias devem ser gozadas no ano subsequente
|
|
* - Servidor com mais de 10 anos: pode acumular até 2 períodos
|
|
* - Preferência: férias no período de 20/12 a 10/01 para docentes
|
|
* - Gestante: pode antecipar ou prorrogar férias
|
|
*
|
|
* ============================================
|
|
* REGRAS SERVIDOR PÚBLICO MUNICIPAL
|
|
* ============================================
|
|
* - Seguem as mesmas diretrizes do regime estadual acima
|
|
*/
|
|
|
|
type RegimeTrabalho = 'clt' | 'estatutario_pe' | 'estatutario_federal' | 'estatutario_municipal';
|
|
|
|
// Configurações por regime
|
|
const REGIMES_CONFIG = {
|
|
clt: {
|
|
nome: 'CLT - Consolidação das Leis do Trabalho',
|
|
maxPeriodos: 3,
|
|
minDiasPeriodo: 5,
|
|
minDiasPeriodoPrincipal: 14,
|
|
abonoPermitido: true,
|
|
maxDiasAbono: 10
|
|
},
|
|
estatutario_pe: {
|
|
nome: 'Servidor Público Estadual de Pernambuco',
|
|
maxPeriodos: 2,
|
|
minDiasPeriodo: 15, // Mínimo 15 dias por período
|
|
minDiasPeriodoPrincipal: null, // Não há essa regra
|
|
abonoPermitido: false,
|
|
maxDiasAbono: 0,
|
|
periodosPermitidos: [15, 30] // Apenas 15 ou 30 dias por período
|
|
},
|
|
estatutario_federal: {
|
|
nome: 'Servidor Público Federal',
|
|
maxPeriodos: 3,
|
|
minDiasPeriodo: 5,
|
|
minDiasPeriodoPrincipal: 14,
|
|
abonoPermitido: true,
|
|
maxDiasAbono: 10
|
|
},
|
|
estatutario_municipal: {
|
|
nome: 'Servidor Público Municipal',
|
|
maxPeriodos: 2,
|
|
minDiasPeriodo: 15, // Mínimo 15 dias por período
|
|
minDiasPeriodoPrincipal: null,
|
|
abonoPermitido: false,
|
|
maxDiasAbono: 0,
|
|
periodosPermitidos: [15, 30] // Apenas 15 ou 30 dias por período
|
|
}
|
|
};
|
|
|
|
// 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; // +1 para incluir ambos os dias
|
|
return diffDays;
|
|
}
|
|
|
|
// Helper: Calcular data de fim do período aquisitivo
|
|
function calcularDataFimPeriodo(dataAdmissao: string, anosPassados: number): string {
|
|
const dataInicio = new Date(dataAdmissao);
|
|
dataInicio.setFullYear(dataInicio.getFullYear() + anosPassados);
|
|
return dataInicio.toISOString().split('T')[0];
|
|
}
|
|
|
|
// Helper: Obter regime de trabalho do funcionário
|
|
async function obterRegimeTrabalho(
|
|
ctx: QueryCtx,
|
|
funcionarioId: Id<'funcionarios'>
|
|
): Promise<RegimeTrabalho> {
|
|
const funcionario = await ctx.db.get(funcionarioId);
|
|
return funcionario?.regimeTrabalho || 'clt'; // Default CLT
|
|
}
|
|
|
|
// Helper: Calcular saldo dinamicamente baseado na tabela ferias
|
|
async function calcularSaldo(
|
|
ctx: QueryCtx,
|
|
funcionarioId: Id<'funcionarios'>,
|
|
anoReferencia: number,
|
|
feriasIdExcluir?: Id<'ferias'> // ID do período a excluir do cálculo (para ajustes)
|
|
): Promise<{
|
|
diasDireito: number;
|
|
diasUsados: number;
|
|
diasPendentes: number;
|
|
diasDisponiveis: number;
|
|
diasAbono: number;
|
|
dataInicio: string;
|
|
dataFim: string;
|
|
status: 'ativo' | 'vencido' | 'concluido';
|
|
} | null> {
|
|
const funcionario = await ctx.db.get(funcionarioId);
|
|
if (!funcionario || !funcionario.admissaoData) return null;
|
|
|
|
const regime = funcionario.regimeTrabalho || 'clt';
|
|
const config = REGIMES_CONFIG[regime];
|
|
|
|
// Calcular anos desde admissão
|
|
const dataAdmissao = new Date(funcionario.admissaoData);
|
|
const anosDesdeAdmissao = anoReferencia - dataAdmissao.getFullYear();
|
|
|
|
if (anosDesdeAdmissao < 1) return null; // Ainda não tem direito
|
|
|
|
const dataInicio = calcularDataFimPeriodo(funcionario.admissaoData, anosDesdeAdmissao - 1);
|
|
const dataFim = calcularDataFimPeriodo(funcionario.admissaoData, anosDesdeAdmissao);
|
|
|
|
// Buscar todos os registros de férias para este funcionário e ano
|
|
const todasFerias = await ctx.db
|
|
.query('ferias')
|
|
.withIndex('by_funcionario_and_ano', (q) =>
|
|
q.eq('funcionarioId', funcionarioId).eq('anoReferencia', anoReferencia)
|
|
)
|
|
.collect();
|
|
|
|
// Filtrar períodos a excluir (para ajustes)
|
|
const feriasFiltradas = feriasIdExcluir
|
|
? todasFerias.filter((f) => f._id !== feriasIdExcluir)
|
|
: todasFerias;
|
|
|
|
// Calcular dias usados (aprovado, data_ajustada_aprovada, EmFérias)
|
|
const diasUsados = feriasFiltradas
|
|
.filter(
|
|
(f) =>
|
|
f.status === 'aprovado' || f.status === 'data_ajustada_aprovada' || f.status === 'EmFérias'
|
|
)
|
|
.reduce((acc, f) => acc + f.diasFerias, 0);
|
|
|
|
// Calcular dias pendentes (aguardando_aprovacao)
|
|
const diasPendentes = feriasFiltradas
|
|
.filter((f) => f.status === 'aguardando_aprovacao')
|
|
.reduce((acc, f) => acc + f.diasFerias, 0);
|
|
|
|
// Calcular dias de abono
|
|
const diasAbono = feriasFiltradas.reduce((acc, f) => acc + f.diasAbono, 0);
|
|
|
|
// Calcular dias disponíveis
|
|
const diasDireito = 30;
|
|
const diasDisponiveis = diasDireito - diasUsados - diasPendentes - diasAbono;
|
|
|
|
// Determinar status do período
|
|
const hoje = new Date();
|
|
const dataFimPeriodo = new Date(dataFim);
|
|
let status: 'ativo' | 'vencido' | 'concluido';
|
|
|
|
if (diasDireito - diasUsados - diasAbono <= 0) {
|
|
status = 'concluido';
|
|
} else if (hoje > dataFimPeriodo) {
|
|
status = 'vencido';
|
|
} else {
|
|
status = 'ativo';
|
|
}
|
|
|
|
return {
|
|
diasDireito,
|
|
diasUsados,
|
|
diasPendentes,
|
|
diasDisponiveis,
|
|
diasAbono,
|
|
dataInicio,
|
|
dataFim,
|
|
status
|
|
};
|
|
}
|
|
|
|
/**
|
|
* Query: Obter saldo de férias de um funcionário para um ano específico
|
|
*/
|
|
export const obterSaldo = query({
|
|
args: {
|
|
funcionarioId: v.id('funcionarios'),
|
|
anoReferencia: v.number()
|
|
},
|
|
returns: v.union(
|
|
v.object({
|
|
anoReferencia: v.number(),
|
|
diasDireito: v.number(),
|
|
diasUsados: v.number(),
|
|
diasPendentes: v.number(),
|
|
diasDisponiveis: v.number(),
|
|
diasAbono: v.number(),
|
|
abonoPermitido: v.boolean(),
|
|
status: v.union(v.literal('ativo'), v.literal('vencido'), v.literal('concluido')),
|
|
dataInicio: v.string(),
|
|
dataFim: v.string(),
|
|
regimeTrabalho: v.string()
|
|
}),
|
|
v.null()
|
|
),
|
|
handler: async (ctx, args) => {
|
|
const saldo = await calcularSaldo(ctx, args.funcionarioId, args.anoReferencia);
|
|
if (!saldo) return null;
|
|
|
|
const funcionario = await ctx.db.get(args.funcionarioId);
|
|
const regime = funcionario?.regimeTrabalho || 'clt';
|
|
const config = REGIMES_CONFIG[regime];
|
|
|
|
return {
|
|
anoReferencia: args.anoReferencia,
|
|
...saldo,
|
|
abonoPermitido: config.abonoPermitido,
|
|
regimeTrabalho: config.nome
|
|
};
|
|
}
|
|
});
|
|
|
|
/**
|
|
* Query: Listar todos os saldos de um funcionário
|
|
*/
|
|
export const listarSaldos = query({
|
|
args: {
|
|
funcionarioId: v.id('funcionarios')
|
|
},
|
|
returns: v.array(
|
|
v.object({
|
|
anoReferencia: v.number(),
|
|
diasDireito: v.number(),
|
|
diasUsados: v.number(),
|
|
diasPendentes: v.number(),
|
|
diasDisponiveis: v.number(),
|
|
diasAbono: v.number(),
|
|
abonoPermitido: v.boolean(),
|
|
status: v.union(v.literal('ativo'), v.literal('vencido'), v.literal('concluido')),
|
|
dataInicio: v.string(),
|
|
dataFim: v.string()
|
|
})
|
|
),
|
|
handler: async (ctx, args) => {
|
|
const funcionario = await ctx.db.get(args.funcionarioId);
|
|
if (!funcionario || !funcionario.admissaoData) return [];
|
|
|
|
const regime = funcionario.regimeTrabalho || 'clt';
|
|
const config = REGIMES_CONFIG[regime];
|
|
|
|
const dataAdmissao = new Date(funcionario.admissaoData);
|
|
const anoAtual = new Date().getFullYear();
|
|
const anosDesdeAdmissao = anoAtual - dataAdmissao.getFullYear();
|
|
|
|
const saldos = [];
|
|
|
|
// Calcular saldos para os últimos 3 anos (atual, anterior e anterior ao anterior)
|
|
for (let i = 0; i < 3; i++) {
|
|
const ano = anoAtual - i;
|
|
const anosPeriodo = ano - dataAdmissao.getFullYear();
|
|
|
|
if (anosPeriodo < 1) continue;
|
|
|
|
const saldo = await calcularSaldo(ctx, args.funcionarioId, ano);
|
|
if (saldo) {
|
|
saldos.push({
|
|
anoReferencia: ano,
|
|
...saldo,
|
|
abonoPermitido: config.abonoPermitido
|
|
});
|
|
}
|
|
}
|
|
|
|
return saldos;
|
|
}
|
|
});
|
|
|
|
/**
|
|
* Query: Validar solicitação de férias (regras CLT ou Servidor Público PE)
|
|
*/
|
|
export const validarSolicitacao = query({
|
|
args: {
|
|
funcionarioId: v.id('funcionarios'),
|
|
anoReferencia: v.number(),
|
|
periodos: v.array(
|
|
v.object({
|
|
dataInicio: v.string(),
|
|
dataFim: v.string()
|
|
})
|
|
),
|
|
feriasIdExcluir: v.optional(v.id('ferias')) // ID do período a excluir do cálculo de saldo (para ajustes)
|
|
},
|
|
returns: v.object({
|
|
valido: v.boolean(),
|
|
erros: v.array(v.string()),
|
|
avisos: v.array(v.string()),
|
|
totalDias: v.number(),
|
|
regimeTrabalho: v.string()
|
|
}),
|
|
handler: async (ctx, args) => {
|
|
const erros: string[] = [];
|
|
const avisos: string[] = [];
|
|
let totalDias = 0;
|
|
|
|
// Obter regime de trabalho
|
|
const regime = await obterRegimeTrabalho(ctx, args.funcionarioId);
|
|
const config = REGIMES_CONFIG[regime];
|
|
|
|
// Validação 1: Número de períodos
|
|
if (args.periodos.length === 0) {
|
|
erros.push('É necessário adicionar pelo menos 1 período de férias');
|
|
}
|
|
|
|
if (args.periodos.length > config.maxPeriodos) {
|
|
erros.push(`Máximo de ${config.maxPeriodos} períodos permitidos para ${config.nome}`);
|
|
}
|
|
|
|
// Calcular dias de cada período e validar
|
|
const diasPorPeriodo: number[] = [];
|
|
for (const periodo of args.periodos) {
|
|
const dias = calcularDiasEntreDatas(periodo.dataInicio, periodo.dataFim);
|
|
diasPorPeriodo.push(dias);
|
|
totalDias += dias;
|
|
|
|
// Validação 2: Mínimo de dias por período
|
|
if (dias < config.minDiasPeriodo) {
|
|
erros.push(
|
|
`Período de ${dias} dias é inválido. Mínimo: ${config.minDiasPeriodo} dias corridos (${config.nome})`
|
|
);
|
|
}
|
|
|
|
// Validação específica para regime estatutário PE e Municipal
|
|
if (
|
|
(regime === 'estatutario_pe' || regime === 'estatutario_municipal') &&
|
|
'periodosPermitidos' in config
|
|
) {
|
|
if (!config.periodosPermitidos.includes(dias)) {
|
|
erros.push(
|
|
`Para ${config.nome}, os períodos devem ter exatamente 15 ou 30 dias. Período de ${dias} dias não é permitido.`
|
|
);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Validação específica para regime estatutário PE e Municipal
|
|
// Permite períodos fracionados: cada período deve ser 15 ou 30 dias
|
|
// Total não pode exceder 30 dias, mas pode ser menos (períodos fracionados)
|
|
if (regime === 'estatutario_pe' || regime === 'estatutario_municipal') {
|
|
// Verificar se cada período individual é válido (15 ou 30 dias)
|
|
for (const dias of diasPorPeriodo) {
|
|
if (dias !== 15 && dias !== 30) {
|
|
erros.push(
|
|
`Para ${config.nome}, cada período deve ter exatamente 15 ou 30 dias. Período de ${dias} dias não é permitido.`
|
|
);
|
|
}
|
|
}
|
|
|
|
// Total não pode exceder 30 dias
|
|
if (totalDias > 30) {
|
|
erros.push(
|
|
`Para ${config.nome}, o total de dias não pode exceder 30 dias. Total solicitado: ${totalDias} dias.`
|
|
);
|
|
}
|
|
|
|
// Máximo de 2 períodos
|
|
if (args.periodos.length > 2) {
|
|
erros.push(`Para ${config.nome}, o máximo de períodos permitidos é 2.`);
|
|
}
|
|
}
|
|
|
|
// Validação 3: CLT requer um período com 14+ dias se dividir
|
|
if (regime === 'clt' && args.periodos.length > 1 && config.minDiasPeriodoPrincipal) {
|
|
const temPeriodo14Dias = diasPorPeriodo.some((d) => d >= config.minDiasPeriodoPrincipal!);
|
|
if (!temPeriodo14Dias) {
|
|
erros.push(
|
|
`Ao dividir férias em CLT, um período deve ter no mínimo ${config.minDiasPeriodoPrincipal} dias corridos`
|
|
);
|
|
}
|
|
}
|
|
|
|
// Validação 4: Verificar saldo disponível (calculado dinamicamente)
|
|
// Se for um ajuste (feriasIdExcluir fornecido), excluir esse período do cálculo
|
|
const saldo = await calcularSaldo(
|
|
ctx,
|
|
args.funcionarioId,
|
|
args.anoReferencia,
|
|
args.feriasIdExcluir
|
|
);
|
|
|
|
if (!saldo) {
|
|
erros.push(`Você ainda não tem direito a férias referentes ao ano ${args.anoReferencia}`);
|
|
} else {
|
|
// Verificar saldo disponível (já excluindo o período original se for ajuste)
|
|
if (totalDias > saldo.diasDisponiveis) {
|
|
erros.push(
|
|
`Total solicitado (${totalDias} dias) excede saldo disponível (${saldo.diasDisponiveis} dias)`
|
|
);
|
|
}
|
|
|
|
// Aviso: Saldo baixo
|
|
if (saldo.diasDisponiveis < 15 && saldo.diasDisponiveis > totalDias) {
|
|
avisos.push(
|
|
`Após essa solicitação, restará ${saldo.diasDisponiveis - totalDias} dias de ${args.anoReferencia}`
|
|
);
|
|
}
|
|
|
|
// Aviso: Férias vencendo
|
|
const hoje = new Date();
|
|
const dataFim = new Date(saldo.dataFim);
|
|
const diasAteVencer = Math.ceil((dataFim.getTime() - hoje.getTime()) / (1000 * 60 * 60 * 24));
|
|
if (diasAteVencer < 90 && diasAteVencer > 0) {
|
|
avisos.push(
|
|
`⚠️ Atenção: Seu período aquisitivo ${args.anoReferencia} vence em ${diasAteVencer} dias!`
|
|
);
|
|
}
|
|
|
|
if (diasAteVencer < 0) {
|
|
avisos.push(
|
|
`⚠️ URGENTE: Seu período aquisitivo ${args.anoReferencia} está VENCIDO há ${Math.abs(diasAteVencer)} dias!`
|
|
);
|
|
}
|
|
}
|
|
|
|
// Validação 5: Verificar conflitos de datas (sobreposição)
|
|
for (let i = 0; i < args.periodos.length; i++) {
|
|
for (let j = i + 1; j < args.periodos.length; j++) {
|
|
const inicio1 = new Date(args.periodos[i].dataInicio);
|
|
const fim1 = new Date(args.periodos[i].dataFim);
|
|
const inicio2 = new Date(args.periodos[j].dataInicio);
|
|
const fim2 = new Date(args.periodos[j].dataFim);
|
|
|
|
if ((inicio1 <= fim2 && fim1 >= inicio2) || (inicio2 <= fim1 && fim2 >= inicio1)) {
|
|
erros.push('Os períodos não podem se sobrepor');
|
|
}
|
|
}
|
|
}
|
|
|
|
// Validação 6: Datas no futuro (aviso)
|
|
const hoje = new Date();
|
|
hoje.setHours(0, 0, 0, 0);
|
|
for (const periodo of args.periodos) {
|
|
const inicio = new Date(periodo.dataInicio);
|
|
if (inicio < hoje) {
|
|
avisos.push('⚠️ Período(s) com data de início no passado ou hoje');
|
|
break;
|
|
}
|
|
}
|
|
|
|
// Validação 7: Servidor PE - aviso sobre período preferencial para docentes
|
|
if (regime === 'estatutario_pe' || regime === 'estatutario_municipal') {
|
|
for (const periodo of args.periodos) {
|
|
const mes = new Date(periodo.dataInicio).getMonth() + 1;
|
|
if (mes === 12 || mes === 1) {
|
|
avisos.push('📅 Período preferencial para docentes (20/12 a 10/01)');
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
return {
|
|
valido: erros.length === 0,
|
|
erros,
|
|
avisos,
|
|
totalDias,
|
|
regimeTrabalho: config.nome
|
|
};
|
|
}
|
|
});
|