877 lines
24 KiB
TypeScript
877 lines
24 KiB
TypeScript
import { v } from 'convex/values';
|
|
import { api } from './_generated/api';
|
|
import type { Doc, Id } from './_generated/dataModel';
|
|
import type { MutationCtx } from './_generated/server';
|
|
import { mutation, query } from './_generated/server';
|
|
import { getCurrentUserFunction } from './auth';
|
|
|
|
const ticketStatusValidator = v.union(
|
|
v.literal('aberto'),
|
|
v.literal('em_andamento'),
|
|
v.literal('aguardando_usuario'),
|
|
v.literal('resolvido'),
|
|
v.literal('encerrado'),
|
|
v.literal('cancelado')
|
|
);
|
|
|
|
const ticketTipoValidator = v.union(
|
|
v.literal('reclamacao'),
|
|
v.literal('elogio'),
|
|
v.literal('sugestao'),
|
|
v.literal('chamado')
|
|
);
|
|
|
|
const prioridadeValidator = v.union(
|
|
v.literal('baixa'),
|
|
v.literal('media'),
|
|
v.literal('alta'),
|
|
v.literal('critica')
|
|
);
|
|
|
|
const arquivoValidator = v.object({
|
|
arquivoId: v.id('_storage'),
|
|
nome: v.optional(v.string()),
|
|
tipo: v.optional(v.string()),
|
|
tamanho: v.optional(v.number())
|
|
});
|
|
|
|
async function assertAuth(ctx: Parameters<typeof getCurrentUserFunction>[0]) {
|
|
const usuario = await getCurrentUserFunction(ctx);
|
|
if (!usuario) {
|
|
throw new Error('Usuário não autenticado');
|
|
}
|
|
return usuario;
|
|
}
|
|
|
|
type TicketDoc = Doc<'tickets'>;
|
|
type SlaDoc = Doc<'slaConfigs'> | null;
|
|
|
|
function gerarNumeroTicket(): string {
|
|
const agora = new Date();
|
|
const ano = agora.getFullYear();
|
|
const mes = String(agora.getMonth() + 1).padStart(2, '0');
|
|
const sequencia = Math.floor(Math.random() * 9000 + 1000);
|
|
return `SGSE-${ano}${mes}-${sequencia}`;
|
|
}
|
|
|
|
function calcularPrazos(base: number, sla: SlaDoc) {
|
|
const horaMs = 60 * 60 * 1000;
|
|
|
|
const tempoResposta = sla?.tempoRespostaHoras ?? 4;
|
|
const tempoConclusao = sla?.tempoConclusaoHoras ?? 24;
|
|
const tempoEncerramento = sla?.tempoEncerramentoHoras ?? null;
|
|
|
|
return {
|
|
resposta: base + tempoResposta * horaMs,
|
|
conclusao: base + tempoConclusao * horaMs,
|
|
encerramento: tempoEncerramento ? base + tempoEncerramento * horaMs : null
|
|
};
|
|
}
|
|
|
|
function montarTimeline(base: number, prazos: ReturnType<typeof calcularPrazos>) {
|
|
const timeline: NonNullable<TicketDoc['timeline']> = [
|
|
{
|
|
etapa: 'abertura',
|
|
status: 'concluido',
|
|
prazo: base,
|
|
concluidoEm: base,
|
|
observacao: 'Chamado registrado com sucesso'
|
|
},
|
|
{
|
|
etapa: 'resposta_inicial',
|
|
status: 'pendente',
|
|
prazo: prazos.resposta
|
|
},
|
|
{
|
|
etapa: 'conclusao',
|
|
status: 'pendente',
|
|
prazo: prazos.conclusao
|
|
}
|
|
];
|
|
|
|
if (prazos.encerramento) {
|
|
timeline.push({
|
|
etapa: 'encerramento',
|
|
status: 'pendente',
|
|
prazo: prazos.encerramento
|
|
});
|
|
}
|
|
|
|
return timeline;
|
|
}
|
|
|
|
async function selecionarSlaConfig(
|
|
ctx: Parameters<typeof getCurrentUserFunction>[0],
|
|
prioridade: 'baixa' | 'media' | 'alta' | 'critica'
|
|
): Promise<Doc<'slaConfigs'> | null> {
|
|
return await ctx.db
|
|
.query('slaConfigs')
|
|
.withIndex('by_prioridade', (q) => q.eq('prioridade', prioridade).eq('ativo', true))
|
|
.first();
|
|
}
|
|
|
|
async function registrarNotificacoes(
|
|
ctx: MutationCtx,
|
|
params: {
|
|
ticket: Doc<'tickets'>;
|
|
titulo: string;
|
|
mensagem: string;
|
|
usuarioEvento: Id<'usuarios'>;
|
|
}
|
|
) {
|
|
const { ticket, titulo, mensagem, usuarioEvento } = params;
|
|
|
|
// Obter URL do sistema
|
|
let urlSistema = process.env.FRONTEND_URL || 'http://localhost:5173';
|
|
if (!urlSistema.match(/^https?:\/\//i)) {
|
|
urlSistema = `http://${urlSistema}`;
|
|
}
|
|
|
|
// Notificar solicitante
|
|
if (ticket.solicitanteEmail) {
|
|
// Tentar usar template, senão usar envio direto
|
|
try {
|
|
await ctx.scheduler.runAfter(0, api.email.enviarEmailComTemplate, {
|
|
destinatario: ticket.solicitanteEmail,
|
|
destinatarioId: ticket.solicitanteId,
|
|
templateCodigo: 'chamado_atualizado',
|
|
variaveis: {
|
|
solicitante: ticket.solicitanteNome || 'Usuário',
|
|
numeroTicket: ticket.numero,
|
|
mensagem: mensagem,
|
|
urlSistema
|
|
},
|
|
enviadoPor: usuarioEvento
|
|
});
|
|
} catch (error) {
|
|
// Fallback para envio direto
|
|
console.warn(
|
|
'Erro ao agendar envio de email com template chamado_atualizado para solicitante, usando envio direto:',
|
|
error
|
|
);
|
|
await ctx.runMutation(api.email.enfileirarEmail, {
|
|
destinatario: ticket.solicitanteEmail,
|
|
destinatarioId: ticket.solicitanteId,
|
|
assunto: `${titulo} - Chamado ${ticket.numero}`,
|
|
corpo: `${mensagem}\n\n---\nCentral de Chamados SGSE - Sistema de Gerenciamento de Secretaria`,
|
|
enviadoPor: usuarioEvento
|
|
});
|
|
}
|
|
}
|
|
|
|
await ctx.db.insert('notificacoes', {
|
|
usuarioId: ticket.solicitanteId,
|
|
tipo: 'nova_mensagem',
|
|
...(ticket.conversaId ? { conversaId: ticket.conversaId } : {}),
|
|
remetenteId: usuarioEvento,
|
|
titulo,
|
|
descricao: mensagem.length > 120 ? `${mensagem.slice(0, 117)}...` : mensagem,
|
|
lida: false,
|
|
criadaEm: Date.now()
|
|
});
|
|
|
|
// Se o ticket estiver associado a uma conversa, registrar também uma mensagem de chat
|
|
// Isso garante o "duplo canal": email + chat para notificações importantes.
|
|
if (ticket.conversaId) {
|
|
const conteudoChat = mensagem.length > 0 ? `${titulo}: ${mensagem}` : titulo;
|
|
|
|
await ctx.db.insert('mensagens', {
|
|
conversaId: ticket.conversaId,
|
|
remetenteId: usuarioEvento,
|
|
tipo: 'texto',
|
|
conteudo: conteudoChat,
|
|
enviadaEm: Date.now()
|
|
});
|
|
}
|
|
|
|
// Notificar responsável (se houver)
|
|
if (ticket.responsavelId && ticket.responsavelId !== ticket.solicitanteId) {
|
|
const responsavel = await ctx.db.get(ticket.responsavelId);
|
|
if (responsavel?.email) {
|
|
// Tentar usar template, senão usar envio direto
|
|
try {
|
|
await ctx.scheduler.runAfter(0, api.email.enviarEmailComTemplate, {
|
|
destinatario: responsavel.email,
|
|
destinatarioId: ticket.responsavelId,
|
|
templateCodigo: 'chamado_atualizado',
|
|
variaveis: {
|
|
solicitante: ticket.solicitanteNome || 'Usuário',
|
|
numeroTicket: ticket.numero,
|
|
mensagem: mensagem,
|
|
urlSistema
|
|
},
|
|
enviadoPor: usuarioEvento
|
|
});
|
|
} catch (error) {
|
|
// Fallback para envio direto
|
|
console.warn(
|
|
'Erro ao agendar envio de email com template chamado_atualizado para responsável, usando envio direto:',
|
|
error
|
|
);
|
|
await ctx.runMutation(api.email.enfileirarEmail, {
|
|
destinatario: responsavel.email,
|
|
destinatarioId: ticket.responsavelId,
|
|
assunto: `${titulo} - Chamado ${ticket.numero}`,
|
|
corpo: `${mensagem}\n\n---\nCentral de Chamados SGSE - Sistema de Gerenciamento de Secretaria`,
|
|
enviadoPor: usuarioEvento
|
|
});
|
|
}
|
|
}
|
|
|
|
await ctx.db.insert('notificacoes', {
|
|
usuarioId: ticket.responsavelId,
|
|
tipo: 'nova_mensagem',
|
|
...(ticket.conversaId ? { conversaId: ticket.conversaId } : {}),
|
|
remetenteId: usuarioEvento,
|
|
titulo,
|
|
descricao: mensagem.length > 120 ? `${mensagem.slice(0, 117)}...` : mensagem,
|
|
lida: false,
|
|
criadaEm: Date.now()
|
|
});
|
|
}
|
|
}
|
|
|
|
async function registrarInteracao(
|
|
ctx: MutationCtx,
|
|
params: {
|
|
ticketId: Id<'tickets'>;
|
|
autorId: Id<'usuarios'> | null;
|
|
origem: 'usuario' | 'ti' | 'sistema';
|
|
tipo: 'mensagem' | 'status' | 'anexo' | 'alerta';
|
|
conteudo: string;
|
|
visibilidade?: 'publico' | 'interno';
|
|
anexos?: Array<{
|
|
arquivoId: Id<'_storage'>;
|
|
nome?: string;
|
|
tipo?: string;
|
|
tamanho?: number;
|
|
}>;
|
|
statusAnterior?: TicketDoc['status'];
|
|
statusNovo?: TicketDoc['status'];
|
|
}
|
|
) {
|
|
return await ctx.db.insert('ticketInteractions', {
|
|
ticketId: params.ticketId,
|
|
autorId: params.autorId || undefined,
|
|
origem: params.origem,
|
|
tipo: params.tipo,
|
|
conteudo: params.conteudo,
|
|
visibilidade: params.visibilidade ?? 'publico',
|
|
anexos: params.anexos,
|
|
statusAnterior: params.statusAnterior,
|
|
statusNovo: params.statusNovo,
|
|
criadoEm: Date.now()
|
|
});
|
|
}
|
|
|
|
export const abrirChamado = mutation({
|
|
args: {
|
|
titulo: v.string(),
|
|
descricao: v.string(),
|
|
tipo: ticketTipoValidator,
|
|
categoria: v.optional(v.string()),
|
|
prioridade: prioridadeValidator,
|
|
anexos: v.optional(v.array(arquivoValidator)),
|
|
canalOrigem: v.optional(v.string())
|
|
},
|
|
returns: v.object({
|
|
ticketId: v.id('tickets'),
|
|
numero: v.string()
|
|
}),
|
|
handler: async (ctx, args) => {
|
|
const usuario = await assertAuth(ctx);
|
|
const agora = Date.now();
|
|
const sla = await selecionarSlaConfig(ctx, args.prioridade);
|
|
const prazos = calcularPrazos(agora, sla);
|
|
const timeline = montarTimeline(agora, prazos);
|
|
|
|
const ticketId = await ctx.db.insert('tickets', {
|
|
numero: gerarNumeroTicket(),
|
|
titulo: args.titulo.trim(),
|
|
descricao: args.descricao.trim(),
|
|
tipo: args.tipo,
|
|
categoria: args.categoria,
|
|
status: 'aberto',
|
|
prioridade: args.prioridade,
|
|
solicitanteId: usuario._id,
|
|
solicitanteNome: usuario.nome,
|
|
solicitanteEmail: usuario.email,
|
|
responsavelId: undefined,
|
|
setorResponsavel: undefined,
|
|
slaConfigId: sla?._id,
|
|
conversaId: undefined,
|
|
prazoResposta: prazos.resposta,
|
|
prazoConclusao: prazos.conclusao,
|
|
prazoEncerramento: prazos.encerramento ?? undefined,
|
|
timeline,
|
|
alertasEmitidos: [],
|
|
anexos: args.anexos,
|
|
tags: undefined,
|
|
canalOrigem: args.canalOrigem,
|
|
ultimaInteracaoEm: agora,
|
|
criadoEm: agora,
|
|
atualizadoEm: agora
|
|
});
|
|
|
|
await registrarInteracao(ctx, {
|
|
ticketId,
|
|
autorId: usuario._id,
|
|
origem: 'usuario',
|
|
tipo: 'mensagem',
|
|
conteudo: args.descricao,
|
|
anexos: args.anexos
|
|
});
|
|
|
|
const ticket = await ctx.db.get(ticketId);
|
|
if (ticket) {
|
|
await registrarNotificacoes(ctx, {
|
|
ticket,
|
|
titulo: 'Chamado registrado',
|
|
mensagem: 'Recebemos sua solicitação e iniciaremos o atendimento em breve.',
|
|
usuarioEvento: usuario._id
|
|
});
|
|
}
|
|
|
|
return {
|
|
ticketId,
|
|
numero: ticket ? ticket.numero : ''
|
|
};
|
|
}
|
|
});
|
|
|
|
export const listarChamadosUsuario = query({
|
|
args: {},
|
|
handler: async (ctx) => {
|
|
const usuario = await assertAuth(ctx);
|
|
|
|
const tickets = await ctx.db
|
|
.query('tickets')
|
|
.withIndex('by_solicitante', (q) => q.eq('solicitanteId', usuario._id))
|
|
.collect();
|
|
|
|
tickets.sort((a, b) => b.criadoEm - a.criadoEm);
|
|
return tickets;
|
|
}
|
|
});
|
|
|
|
export const listarChamadosTI = query({
|
|
args: {
|
|
status: v.optional(ticketStatusValidator),
|
|
responsavelId: v.optional(v.id('usuarios')),
|
|
setor: v.optional(v.string()),
|
|
limite: v.optional(v.number())
|
|
},
|
|
handler: async (ctx, args) => {
|
|
// Permitir apenas usuários autenticados (regras detalhadas devem ser aplicadas no frontend)
|
|
await assertAuth(ctx);
|
|
|
|
let tickets: Array<Doc<'tickets'>> = [];
|
|
|
|
if (args.responsavelId) {
|
|
tickets = await ctx.db
|
|
.query('tickets')
|
|
.withIndex('by_responsavel', (q) =>
|
|
q.eq('responsavelId', args.responsavelId).eq('status', args.status ?? 'aberto')
|
|
)
|
|
.collect();
|
|
} else if (args.status) {
|
|
tickets = await ctx.db
|
|
.query('tickets')
|
|
.withIndex('by_status', (q) => q.eq('status', args.status!))
|
|
.collect();
|
|
} else {
|
|
tickets = await ctx.db.query('tickets').collect();
|
|
}
|
|
|
|
const filtrados = tickets.filter((ticket) => {
|
|
if (args.setor && ticket.setorResponsavel !== args.setor) {
|
|
return false;
|
|
}
|
|
return true;
|
|
});
|
|
|
|
// Enriquecer tickets com nome do responsável
|
|
const ticketsEnriquecidos = await Promise.all(
|
|
filtrados.map(async (ticket) => {
|
|
let responsavelNome: string | undefined;
|
|
if (ticket.responsavelId) {
|
|
const responsavel = await ctx.db.get(ticket.responsavelId);
|
|
responsavelNome = responsavel?.nome;
|
|
}
|
|
return {
|
|
...ticket,
|
|
responsavelNome
|
|
};
|
|
})
|
|
);
|
|
|
|
ticketsEnriquecidos.sort((a, b) => b.atualizadoEm - a.atualizadoEm);
|
|
return args.limite ? ticketsEnriquecidos.slice(0, args.limite) : ticketsEnriquecidos;
|
|
}
|
|
});
|
|
|
|
export const obterChamado = query({
|
|
args: {
|
|
ticketId: v.id('tickets')
|
|
},
|
|
handler: async (ctx, args) => {
|
|
const usuario = await assertAuth(ctx);
|
|
const ticket = await ctx.db.get(args.ticketId);
|
|
if (!ticket) {
|
|
throw new Error('Chamado não encontrado');
|
|
}
|
|
|
|
const podeVer =
|
|
ticket.solicitanteId === usuario._id ||
|
|
ticket.responsavelId === usuario._id ||
|
|
ticket.setorResponsavel === usuario.setor;
|
|
|
|
if (!podeVer) {
|
|
throw new Error('Acesso negado ao chamado');
|
|
}
|
|
|
|
const interactions = await ctx.db
|
|
.query('ticketInteractions')
|
|
.withIndex('by_ticket', (q) => q.eq('ticketId', args.ticketId))
|
|
.collect();
|
|
|
|
interactions.sort((a, b) => a.criadoEm - b.criadoEm);
|
|
|
|
return {
|
|
ticket,
|
|
interactions
|
|
};
|
|
}
|
|
});
|
|
|
|
export const registrarAtualizacao = mutation({
|
|
args: {
|
|
ticketId: v.id('tickets'),
|
|
conteudo: v.string(),
|
|
anexos: v.optional(v.array(arquivoValidator)),
|
|
visibilidade: v.optional(v.union(v.literal('publico'), v.literal('interno'))),
|
|
proximoStatus: v.optional(ticketStatusValidator)
|
|
},
|
|
handler: async (ctx, args) => {
|
|
const usuario = await assertAuth(ctx);
|
|
const ticket = await ctx.db.get(args.ticketId);
|
|
if (!ticket) {
|
|
throw new Error('Chamado não encontrado');
|
|
}
|
|
|
|
const agora = Date.now();
|
|
let novoStatus = ticket.status;
|
|
|
|
if (args.proximoStatus && args.proximoStatus !== ticket.status) {
|
|
novoStatus = args.proximoStatus;
|
|
await ctx.db.patch(ticket._id, {
|
|
status: novoStatus,
|
|
atualizadoEm: agora,
|
|
ultimaInteracaoEm: agora
|
|
});
|
|
} else {
|
|
await ctx.db.patch(ticket._id, {
|
|
atualizadoEm: agora,
|
|
ultimaInteracaoEm: agora
|
|
});
|
|
}
|
|
|
|
await registrarInteracao(ctx, {
|
|
ticketId: ticket._id,
|
|
autorId: usuario._id,
|
|
origem: 'ti',
|
|
tipo: args.proximoStatus ? 'status' : 'mensagem',
|
|
conteudo: args.conteudo,
|
|
visibilidade: args.visibilidade,
|
|
anexos: args.anexos,
|
|
statusAnterior: args.proximoStatus ? ticket.status : undefined,
|
|
statusNovo: args.proximoStatus ? novoStatus : undefined
|
|
});
|
|
|
|
const ticketAtualizado = await ctx.db.get(ticket._id);
|
|
if (ticketAtualizado) {
|
|
await registrarNotificacoes(ctx, {
|
|
ticket: ticketAtualizado,
|
|
titulo: `Atualização no chamado ${ticketAtualizado.numero}`,
|
|
mensagem: args.conteudo,
|
|
usuarioEvento: usuario._id
|
|
});
|
|
}
|
|
|
|
return { status: novoStatus };
|
|
}
|
|
});
|
|
|
|
export const atribuirResponsavel = mutation({
|
|
args: {
|
|
ticketId: v.id('tickets'),
|
|
responsavelId: v.id('usuarios'),
|
|
motivo: v.optional(v.string())
|
|
},
|
|
handler: async (ctx, args) => {
|
|
const usuario = await assertAuth(ctx);
|
|
const ticket = await ctx.db.get(args.ticketId);
|
|
if (!ticket) {
|
|
throw new Error('Chamado não encontrado');
|
|
}
|
|
|
|
const responsavel = await ctx.db.get(args.responsavelId);
|
|
if (!responsavel) {
|
|
throw new Error('Responsável inválido');
|
|
}
|
|
|
|
const agora = Date.now();
|
|
|
|
await ctx.db.patch(ticket._id, {
|
|
responsavelId: args.responsavelId,
|
|
setorResponsavel: responsavel.setor,
|
|
atualizadoEm: agora
|
|
});
|
|
|
|
const assignmentsAtivos = await ctx.db
|
|
.query('ticketAssignments')
|
|
.withIndex('by_ticket', (q) => q.eq('ticketId', ticket._id).eq('ativo', true))
|
|
.collect();
|
|
|
|
for (const assignment of assignmentsAtivos) {
|
|
await ctx.db.patch(assignment._id, {
|
|
ativo: false,
|
|
encerradoEm: agora
|
|
});
|
|
}
|
|
|
|
await ctx.db.insert('ticketAssignments', {
|
|
ticketId: ticket._id,
|
|
responsavelId: args.responsavelId,
|
|
atribuidoPor: usuario._id,
|
|
motivo: args.motivo,
|
|
ativo: true,
|
|
criadoEm: agora,
|
|
encerradoEm: undefined
|
|
});
|
|
|
|
await registrarInteracao(ctx, {
|
|
ticketId: ticket._id,
|
|
autorId: usuario._id,
|
|
origem: 'ti',
|
|
tipo: 'status',
|
|
conteudo: `Chamado atribuído para ${responsavel.nome}`
|
|
});
|
|
|
|
const ticketAtualizado = await ctx.db.get(ticket._id);
|
|
if (ticketAtualizado) {
|
|
await registrarNotificacoes(ctx, {
|
|
ticket: ticketAtualizado,
|
|
titulo: 'Chamado atribuído',
|
|
mensagem: `Seu chamado agora está com ${responsavel.nome}.`,
|
|
usuarioEvento: usuario._id
|
|
});
|
|
}
|
|
|
|
return { responsavelId: args.responsavelId };
|
|
}
|
|
});
|
|
|
|
export const listarSlaConfigs = query({
|
|
args: {},
|
|
handler: async (ctx) => {
|
|
await assertAuth(ctx);
|
|
const slaConfigs = await ctx.db.query('slaConfigs').collect();
|
|
slaConfigs.sort((a, b) => b.criadoEm - a.criadoEm);
|
|
return slaConfigs;
|
|
}
|
|
});
|
|
|
|
export const obterEstatisticasChamados = query({
|
|
args: {},
|
|
handler: async (ctx) => {
|
|
await assertAuth(ctx);
|
|
const todosTickets = await ctx.db.query('tickets').collect();
|
|
|
|
const total = todosTickets.length;
|
|
const abertos = todosTickets.filter((t) => t.status === 'aberto').length;
|
|
const emAndamento = todosTickets.filter((t) => t.status === 'em_andamento').length;
|
|
const vencidos = todosTickets.filter(
|
|
(t) => (t.prazoConclusao && t.prazoConclusao < Date.now()) || t.status === 'cancelado'
|
|
).length;
|
|
|
|
return { total, abertos, emAndamento, vencidos };
|
|
}
|
|
});
|
|
|
|
export const obterDadosSlaGrafico = query({
|
|
args: {},
|
|
handler: async (ctx) => {
|
|
await assertAuth(ctx);
|
|
const agora = Date.now();
|
|
const todosTickets = await ctx.db.query('tickets').collect();
|
|
const slaConfigs = await ctx.db.query('slaConfigs').collect();
|
|
|
|
// Agrupar SLAs por prioridade
|
|
const slaPorPrioridade = new Map<string, Doc<'slaConfigs'>>();
|
|
slaConfigs
|
|
.filter((s) => s.ativo)
|
|
.forEach((sla) => {
|
|
if (sla.prioridade) {
|
|
slaPorPrioridade.set(sla.prioridade, sla);
|
|
}
|
|
});
|
|
|
|
// Calcular status de SLA para cada ticket
|
|
const statusSla = {
|
|
dentroPrazo: 0,
|
|
proximoVencimento: 0,
|
|
vencido: 0,
|
|
semPrazo: 0
|
|
};
|
|
|
|
const porPrioridade = {
|
|
baixa: { dentroPrazo: 0, proximoVencimento: 0, vencido: 0, total: 0 },
|
|
media: { dentroPrazo: 0, proximoVencimento: 0, vencido: 0, total: 0 },
|
|
alta: { dentroPrazo: 0, proximoVencimento: 0, vencido: 0, total: 0 },
|
|
critica: { dentroPrazo: 0, proximoVencimento: 0, vencido: 0, total: 0 }
|
|
};
|
|
|
|
todosTickets.forEach((ticket) => {
|
|
if (!ticket.prazoConclusao) {
|
|
statusSla.semPrazo++;
|
|
return;
|
|
}
|
|
|
|
const prazoConclusao = ticket.prazoConclusao;
|
|
const horasRestantes = (prazoConclusao - agora) / (1000 * 60 * 60);
|
|
const sla = slaPorPrioridade.get(ticket.prioridade);
|
|
const alertaHoras = sla?.alertaAntecedenciaHoras ?? 2;
|
|
|
|
if (prazoConclusao < agora) {
|
|
statusSla.vencido++;
|
|
if (ticket.prioridade && porPrioridade[ticket.prioridade as keyof typeof porPrioridade]) {
|
|
porPrioridade[ticket.prioridade as keyof typeof porPrioridade].vencido++;
|
|
porPrioridade[ticket.prioridade as keyof typeof porPrioridade].total++;
|
|
}
|
|
} else if (horasRestantes <= alertaHoras) {
|
|
statusSla.proximoVencimento++;
|
|
if (ticket.prioridade && porPrioridade[ticket.prioridade as keyof typeof porPrioridade]) {
|
|
porPrioridade[ticket.prioridade as keyof typeof porPrioridade].proximoVencimento++;
|
|
porPrioridade[ticket.prioridade as keyof typeof porPrioridade].total++;
|
|
}
|
|
} else {
|
|
statusSla.dentroPrazo++;
|
|
if (ticket.prioridade && porPrioridade[ticket.prioridade as keyof typeof porPrioridade]) {
|
|
porPrioridade[ticket.prioridade as keyof typeof porPrioridade].dentroPrazo++;
|
|
porPrioridade[ticket.prioridade as keyof typeof porPrioridade].total++;
|
|
}
|
|
}
|
|
});
|
|
|
|
// Calcular taxa de cumprimento
|
|
const totalComPrazo = statusSla.dentroPrazo + statusSla.proximoVencimento + statusSla.vencido;
|
|
const taxaCumprimento =
|
|
totalComPrazo > 0 ? Math.round((statusSla.dentroPrazo / totalComPrazo) * 100) : 100;
|
|
|
|
return {
|
|
statusSla,
|
|
porPrioridade,
|
|
taxaCumprimento,
|
|
totalComPrazo,
|
|
atualizadoEm: agora
|
|
};
|
|
}
|
|
});
|
|
|
|
export const salvarSlaConfig = mutation({
|
|
args: {
|
|
slaId: v.optional(v.id('slaConfigs')),
|
|
nome: v.string(),
|
|
descricao: v.optional(v.string()),
|
|
prioridade: prioridadeValidator,
|
|
tempoRespostaHoras: v.number(),
|
|
tempoConclusaoHoras: v.number(),
|
|
tempoEncerramentoHoras: v.optional(v.number()),
|
|
alertaAntecedenciaHoras: v.number(),
|
|
ativo: v.boolean()
|
|
},
|
|
handler: async (ctx, args) => {
|
|
const usuario = await assertAuth(ctx);
|
|
const agora = Date.now();
|
|
|
|
if (args.slaId) {
|
|
await ctx.db.patch(args.slaId, {
|
|
nome: args.nome,
|
|
descricao: args.descricao,
|
|
prioridade: args.prioridade,
|
|
tempoRespostaHoras: args.tempoRespostaHoras,
|
|
tempoConclusaoHoras: args.tempoConclusaoHoras,
|
|
tempoEncerramentoHoras: args.tempoEncerramentoHoras,
|
|
alertaAntecedenciaHoras: args.alertaAntecedenciaHoras,
|
|
ativo: args.ativo,
|
|
atualizadoPor: usuario._id,
|
|
atualizadoEm: agora
|
|
});
|
|
return args.slaId;
|
|
}
|
|
|
|
return await ctx.db.insert('slaConfigs', {
|
|
nome: args.nome,
|
|
descricao: args.descricao,
|
|
prioridade: args.prioridade,
|
|
tempoRespostaHoras: args.tempoRespostaHoras,
|
|
tempoConclusaoHoras: args.tempoConclusaoHoras,
|
|
tempoEncerramentoHoras: args.tempoEncerramentoHoras,
|
|
alertaAntecedenciaHoras: args.alertaAntecedenciaHoras,
|
|
ativo: args.ativo,
|
|
criadoPor: usuario._id,
|
|
atualizadoPor: usuario._id,
|
|
criadoEm: agora,
|
|
atualizadoEm: agora
|
|
});
|
|
}
|
|
});
|
|
|
|
export const excluirSlaConfig = mutation({
|
|
args: {
|
|
slaId: v.id('slaConfigs')
|
|
},
|
|
handler: async (ctx, args) => {
|
|
await assertAuth(ctx);
|
|
const sla = await ctx.db.get(args.slaId);
|
|
if (!sla) {
|
|
throw new Error('Configuração de SLA não encontrada');
|
|
}
|
|
await ctx.db.delete(args.slaId);
|
|
return { sucesso: true };
|
|
}
|
|
});
|
|
|
|
export const prorrogarChamado = mutation({
|
|
args: {
|
|
ticketId: v.id('tickets'),
|
|
horasAdicionais: v.number(),
|
|
prazo: v.union(v.literal('resposta'), v.literal('conclusao')),
|
|
motivo: v.string()
|
|
},
|
|
handler: async (ctx, args) => {
|
|
const usuario = await assertAuth(ctx);
|
|
const ticket = await ctx.db.get(args.ticketId);
|
|
if (!ticket) {
|
|
throw new Error('Chamado não encontrado');
|
|
}
|
|
|
|
const agora = Date.now();
|
|
const horasMs = args.horasAdicionais * 60 * 60 * 1000;
|
|
let novoPrazoResposta = ticket.prazoResposta;
|
|
let novoPrazoConclusao = ticket.prazoConclusao;
|
|
let prazoExtendido: number;
|
|
|
|
if (args.prazo === 'resposta') {
|
|
prazoExtendido = (ticket.prazoResposta || agora) + horasMs;
|
|
novoPrazoResposta = prazoExtendido;
|
|
// Se o prazo de conclusão é antes do novo prazo de resposta, ajuste-o também
|
|
if (ticket.prazoConclusao && ticket.prazoConclusao < prazoExtendido) {
|
|
novoPrazoConclusao =
|
|
prazoExtendido + (ticket.prazoConclusao - (ticket.prazoResposta || agora));
|
|
}
|
|
} else {
|
|
prazoExtendido = (ticket.prazoConclusao || agora) + horasMs;
|
|
novoPrazoConclusao = prazoExtendido;
|
|
}
|
|
|
|
// Atualizar timeline
|
|
const timelineAtualizada =
|
|
ticket.timeline?.map((etapa) => {
|
|
if (args.prazo === 'resposta' && etapa.etapa === 'resposta_inicial') {
|
|
return {
|
|
...etapa,
|
|
prazo: prazoExtendido,
|
|
status: prazoExtendido > agora ? 'pendente' : etapa.status
|
|
};
|
|
}
|
|
if (args.prazo === 'conclusao' && etapa.etapa === 'conclusao') {
|
|
return {
|
|
...etapa,
|
|
prazo: prazoExtendido,
|
|
status: prazoExtendido > agora ? 'pendente' : etapa.status
|
|
};
|
|
}
|
|
return etapa;
|
|
}) || ticket.timeline;
|
|
|
|
await ctx.db.patch(ticket._id, {
|
|
prazoResposta: novoPrazoResposta,
|
|
prazoConclusao: novoPrazoConclusao,
|
|
timeline: timelineAtualizada,
|
|
atualizadoEm: agora,
|
|
ultimaInteracaoEm: agora
|
|
});
|
|
|
|
await registrarInteracao(ctx, {
|
|
ticketId: ticket._id,
|
|
autorId: usuario._id,
|
|
origem: 'ti',
|
|
tipo: 'status',
|
|
conteudo: `Prazo ${args.prazo === 'resposta' ? 'de resposta' : 'de conclusão'} prorrogado em ${args.horasAdicionais}h. Motivo: ${args.motivo}`
|
|
});
|
|
|
|
const ticketAtualizado = await ctx.db.get(ticket._id);
|
|
if (ticketAtualizado) {
|
|
await registrarNotificacoes(ctx, {
|
|
ticket: ticketAtualizado,
|
|
titulo: `Prazo prorrogado - Chamado ${ticketAtualizado.numero}`,
|
|
mensagem: `O prazo ${args.prazo === 'resposta' ? 'de resposta' : 'de conclusão'} foi prorrogado em ${args.horasAdicionais} horas. Motivo: ${args.motivo}`,
|
|
usuarioEvento: usuario._id
|
|
});
|
|
}
|
|
|
|
return { sucesso: true };
|
|
}
|
|
});
|
|
|
|
export const emitirAlertaPrazo = mutation({
|
|
args: {
|
|
ticketId: v.id('tickets'),
|
|
tipo: v.union(v.literal('resposta'), v.literal('conclusao'), v.literal('encerramento')),
|
|
mensagem: v.string()
|
|
},
|
|
handler: async (ctx, args) => {
|
|
const usuario = await assertAuth(ctx);
|
|
const ticket = await ctx.db.get(args.ticketId);
|
|
if (!ticket) {
|
|
throw new Error('Chamado não encontrado');
|
|
}
|
|
|
|
const atualizado = [
|
|
...(ticket.alertasEmitidos || []),
|
|
{ tipo: args.tipo, emitidoEm: Date.now() }
|
|
];
|
|
|
|
await ctx.db.patch(ticket._id, {
|
|
alertasEmitidos: atualizado
|
|
});
|
|
|
|
await registrarInteracao(ctx, {
|
|
ticketId: ticket._id,
|
|
autorId: usuario._id,
|
|
origem: 'sistema',
|
|
tipo: 'alerta',
|
|
conteudo: args.mensagem
|
|
});
|
|
|
|
await registrarNotificacoes(ctx, {
|
|
ticket,
|
|
titulo: `Alerta de SLA (${args.tipo})`,
|
|
mensagem: args.mensagem,
|
|
usuarioEvento: usuario._id
|
|
});
|
|
|
|
return { sucesso: true };
|
|
}
|
|
});
|
|
|
|
export const generateUploadUrl = mutation({
|
|
args: {},
|
|
handler: async (ctx) => {
|
|
await assertAuth(ctx);
|
|
return await ctx.storage.generateUploadUrl();
|
|
}
|
|
});
|