852 lines
22 KiB
TypeScript
852 lines
22 KiB
TypeScript
import { v } from 'convex/values';
|
|
import type { Id } from './_generated/dataModel';
|
|
import type { MutationCtx, QueryCtx } from './_generated/server';
|
|
import { mutation, query } from './_generated/server';
|
|
|
|
// ========== HELPERS ==========
|
|
|
|
async function getUsuarioAutenticado(ctx: QueryCtx | MutationCtx) {
|
|
const identity = await ctx.auth.getUserIdentity();
|
|
if (!identity) {
|
|
throw new Error('Usuário não autenticado');
|
|
}
|
|
const usuario = await ctx.db
|
|
.query('usuarios')
|
|
.filter((q) => q.eq(q.field('email'), identity.email))
|
|
.first();
|
|
if (!usuario) {
|
|
throw new Error('Usuário não encontrado');
|
|
}
|
|
return usuario;
|
|
}
|
|
|
|
async function getEtapaAtualDoPedido(ctx: QueryCtx | MutationCtx, pedidoId: Id<'pedidos'>) {
|
|
const etapaAtual = await ctx.db
|
|
.query('pedidoEtapasHistorico')
|
|
.withIndex('by_pedidoId_atual', (q) => q.eq('pedidoId', pedidoId).eq('atual', true))
|
|
.first();
|
|
return etapaAtual;
|
|
}
|
|
|
|
// ========== ETAPAS - QUERIES ==========
|
|
|
|
export const listEtapas = query({
|
|
args: {},
|
|
returns: v.array(
|
|
v.object({
|
|
_id: v.id('pedidoFluxoEtapa'),
|
|
_creationTime: v.number(),
|
|
nome: v.string(),
|
|
codigo: v.string(),
|
|
descricao: v.optional(v.string()),
|
|
setorId: v.optional(v.id('setores')),
|
|
setorNome: v.optional(v.string()),
|
|
tempoEstimadoDias: v.optional(v.number()),
|
|
incluirNoTimeline: v.boolean(),
|
|
ordem: v.number(),
|
|
criadoEm: v.number(),
|
|
atualizadoEm: v.number()
|
|
})
|
|
),
|
|
handler: async (ctx) => {
|
|
const etapas = await ctx.db.query('pedidoFluxoEtapa').withIndex('by_ordem').collect();
|
|
|
|
const result = await Promise.all(
|
|
etapas.map(async (etapa) => {
|
|
let setorNome: string | undefined;
|
|
if (etapa.setorId) {
|
|
const setor = await ctx.db.get(etapa.setorId);
|
|
setorNome = setor?.nome;
|
|
}
|
|
return {
|
|
...etapa,
|
|
setorNome
|
|
};
|
|
})
|
|
);
|
|
|
|
return result;
|
|
}
|
|
});
|
|
|
|
export const getEtapa = query({
|
|
args: { id: v.id('pedidoFluxoEtapa') },
|
|
returns: v.union(
|
|
v.object({
|
|
_id: v.id('pedidoFluxoEtapa'),
|
|
_creationTime: v.number(),
|
|
nome: v.string(),
|
|
codigo: v.string(),
|
|
descricao: v.optional(v.string()),
|
|
setorId: v.optional(v.id('setores')),
|
|
tempoEstimadoDias: v.optional(v.number()),
|
|
incluirNoTimeline: v.boolean(),
|
|
ordem: v.number(),
|
|
criadoEm: v.number(),
|
|
atualizadoEm: v.number()
|
|
}),
|
|
v.null()
|
|
),
|
|
handler: async (ctx, args) => {
|
|
return await ctx.db.get(args.id);
|
|
}
|
|
});
|
|
|
|
export const getEtapaByCodigo = query({
|
|
args: { codigo: v.string() },
|
|
returns: v.union(
|
|
v.object({
|
|
_id: v.id('pedidoFluxoEtapa'),
|
|
_creationTime: v.number(),
|
|
nome: v.string(),
|
|
codigo: v.string(),
|
|
descricao: v.optional(v.string()),
|
|
setorId: v.optional(v.id('setores')),
|
|
tempoEstimadoDias: v.optional(v.number()),
|
|
incluirNoTimeline: v.boolean(),
|
|
ordem: v.number(),
|
|
criadoEm: v.number(),
|
|
atualizadoEm: v.number()
|
|
}),
|
|
v.null()
|
|
),
|
|
handler: async (ctx, args) => {
|
|
return await ctx.db
|
|
.query('pedidoFluxoEtapa')
|
|
.withIndex('by_codigo', (q) => q.eq('codigo', args.codigo))
|
|
.first();
|
|
}
|
|
});
|
|
|
|
// ========== ETAPAS - MUTATIONS ==========
|
|
|
|
export const createEtapa = mutation({
|
|
args: {
|
|
nome: v.string(),
|
|
codigo: v.string(),
|
|
descricao: v.optional(v.string()),
|
|
setorId: v.optional(v.id('setores')),
|
|
tempoEstimadoDias: v.optional(v.number()),
|
|
incluirNoTimeline: v.boolean()
|
|
},
|
|
returns: v.id('pedidoFluxoEtapa'),
|
|
handler: async (ctx, args) => {
|
|
await getUsuarioAutenticado(ctx);
|
|
|
|
// Verificar se já existe etapa com este código
|
|
const existente = await ctx.db
|
|
.query('pedidoFluxoEtapa')
|
|
.withIndex('by_codigo', (q) => q.eq('codigo', args.codigo))
|
|
.first();
|
|
|
|
if (existente) {
|
|
throw new Error(`Já existe uma etapa com o código "${args.codigo}"`);
|
|
}
|
|
|
|
// Obter a maior ordem atual
|
|
const todasEtapas = await ctx.db.query('pedidoFluxoEtapa').collect();
|
|
const maiorOrdem = todasEtapas.reduce((max, e) => Math.max(max, e.ordem), 0);
|
|
|
|
const now = Date.now();
|
|
return await ctx.db.insert('pedidoFluxoEtapa', {
|
|
nome: args.nome,
|
|
codigo: args.codigo,
|
|
descricao: args.descricao,
|
|
setorId: args.setorId,
|
|
tempoEstimadoDias: args.tempoEstimadoDias,
|
|
incluirNoTimeline: args.incluirNoTimeline,
|
|
ordem: maiorOrdem + 1,
|
|
criadoEm: now,
|
|
atualizadoEm: now
|
|
});
|
|
}
|
|
});
|
|
|
|
export const updateEtapa = mutation({
|
|
args: {
|
|
id: v.id('pedidoFluxoEtapa'),
|
|
nome: v.optional(v.string()),
|
|
codigo: v.optional(v.string()),
|
|
descricao: v.optional(v.string()),
|
|
setorId: v.optional(v.id('setores')),
|
|
tempoEstimadoDias: v.optional(v.number()),
|
|
incluirNoTimeline: v.optional(v.boolean()),
|
|
ordem: v.optional(v.number())
|
|
},
|
|
returns: v.null(),
|
|
handler: async (ctx, args) => {
|
|
await getUsuarioAutenticado(ctx);
|
|
|
|
const etapa = await ctx.db.get(args.id);
|
|
if (!etapa) {
|
|
throw new Error('Etapa não encontrada');
|
|
}
|
|
|
|
const codigo = args.codigo;
|
|
|
|
// Se estiver mudando o código, verificar duplicidade
|
|
if (codigo && codigo !== etapa.codigo) {
|
|
const existente = await ctx.db
|
|
.query('pedidoFluxoEtapa')
|
|
.withIndex('by_codigo', (q) => q.eq('codigo', codigo))
|
|
.first();
|
|
|
|
if (existente) {
|
|
throw new Error(`Já existe uma etapa com o código "${args.codigo}"`);
|
|
}
|
|
}
|
|
|
|
await ctx.db.patch(args.id, {
|
|
...(args.nome !== undefined && { nome: args.nome }),
|
|
...(args.codigo !== undefined && { codigo: args.codigo }),
|
|
...(args.descricao !== undefined && { descricao: args.descricao }),
|
|
...(args.setorId !== undefined && { setorId: args.setorId }),
|
|
...(args.tempoEstimadoDias !== undefined && { tempoEstimadoDias: args.tempoEstimadoDias }),
|
|
...(args.incluirNoTimeline !== undefined && { incluirNoTimeline: args.incluirNoTimeline }),
|
|
...(args.ordem !== undefined && { ordem: args.ordem }),
|
|
atualizadoEm: Date.now()
|
|
});
|
|
|
|
return null;
|
|
}
|
|
});
|
|
|
|
export const deleteEtapa = mutation({
|
|
args: { id: v.id('pedidoFluxoEtapa') },
|
|
returns: v.null(),
|
|
handler: async (ctx, args) => {
|
|
await getUsuarioAutenticado(ctx);
|
|
|
|
const etapa = await ctx.db.get(args.id);
|
|
if (!etapa) {
|
|
throw new Error('Etapa não encontrada');
|
|
}
|
|
|
|
// Verificar se há transições usando esta etapa
|
|
const transicoesOrigem = await ctx.db
|
|
.query('pedidoFluxoTransicao')
|
|
.withIndex('by_etapaOrigemId', (q) => q.eq('etapaOrigemId', args.id))
|
|
.collect();
|
|
|
|
if (transicoesOrigem.length > 0) {
|
|
throw new Error('Não é possível excluir: esta etapa possui transições de saída');
|
|
}
|
|
|
|
// Verificar se há transições de destino
|
|
const transicoesDestino = await ctx.db
|
|
.query('pedidoFluxoTransicao')
|
|
.filter((q) => q.eq(q.field('etapaDestinoId'), args.id))
|
|
.collect();
|
|
|
|
if (transicoesDestino.length > 0) {
|
|
throw new Error('Não é possível excluir: esta etapa é destino de outras transições');
|
|
}
|
|
|
|
// Verificar se há histórico usando esta etapa
|
|
const historico = await ctx.db
|
|
.query('pedidoEtapasHistorico')
|
|
.withIndex('by_etapaId', (q) => q.eq('etapaId', args.id))
|
|
.first();
|
|
|
|
if (historico) {
|
|
throw new Error('Não é possível excluir: esta etapa já foi utilizada em pedidos');
|
|
}
|
|
|
|
await ctx.db.delete(args.id);
|
|
return null;
|
|
}
|
|
});
|
|
|
|
export const reordenarEtapas = mutation({
|
|
args: {
|
|
ordens: v.array(
|
|
v.object({
|
|
id: v.id('pedidoFluxoEtapa'),
|
|
ordem: v.number()
|
|
})
|
|
)
|
|
},
|
|
returns: v.null(),
|
|
handler: async (ctx, args) => {
|
|
await getUsuarioAutenticado(ctx);
|
|
|
|
for (const item of args.ordens) {
|
|
await ctx.db.patch(item.id, { ordem: item.ordem, atualizadoEm: Date.now() });
|
|
}
|
|
|
|
return null;
|
|
}
|
|
});
|
|
|
|
// ========== TRANSIÇÕES - QUERIES ==========
|
|
|
|
export const listTransicoes = query({
|
|
args: {},
|
|
returns: v.array(
|
|
v.object({
|
|
_id: v.id('pedidoFluxoTransicao'),
|
|
_creationTime: v.number(),
|
|
etapaOrigemId: v.id('pedidoFluxoEtapa'),
|
|
etapaOrigemNome: v.string(),
|
|
etapaDestinoId: v.id('pedidoFluxoEtapa'),
|
|
etapaDestinoNome: v.string(),
|
|
isPadrao: v.boolean(),
|
|
criadoEm: v.number()
|
|
})
|
|
),
|
|
handler: async (ctx) => {
|
|
const transicoes = await ctx.db.query('pedidoFluxoTransicao').collect();
|
|
|
|
const result = await Promise.all(
|
|
transicoes.map(async (t) => {
|
|
const origem = await ctx.db.get(t.etapaOrigemId);
|
|
const destino = await ctx.db.get(t.etapaDestinoId);
|
|
return {
|
|
...t,
|
|
etapaOrigemNome: origem?.nome ?? 'Desconhecido',
|
|
etapaDestinoNome: destino?.nome ?? 'Desconhecido'
|
|
};
|
|
})
|
|
);
|
|
|
|
return result;
|
|
}
|
|
});
|
|
|
|
export const getProximasEtapas = query({
|
|
args: { pedidoId: v.id('pedidos') },
|
|
returns: v.array(
|
|
v.object({
|
|
_id: v.id('pedidoFluxoEtapa'),
|
|
nome: v.string(),
|
|
codigo: v.string(),
|
|
isPadrao: v.boolean()
|
|
})
|
|
),
|
|
handler: async (ctx, args) => {
|
|
const etapaAtualHistorico = await getEtapaAtualDoPedido(ctx, args.pedidoId);
|
|
|
|
if (!etapaAtualHistorico) {
|
|
// Pedido não tem etapa, retornar a primeira etapa do fluxo
|
|
const primeiraEtapa = await ctx.db.query('pedidoFluxoEtapa').withIndex('by_ordem').first();
|
|
|
|
if (!primeiraEtapa) return [];
|
|
|
|
return [
|
|
{
|
|
_id: primeiraEtapa._id,
|
|
nome: primeiraEtapa.nome,
|
|
codigo: primeiraEtapa.codigo,
|
|
isPadrao: true
|
|
}
|
|
];
|
|
}
|
|
|
|
// Buscar transições a partir da etapa atual
|
|
const transicoes = await ctx.db
|
|
.query('pedidoFluxoTransicao')
|
|
.withIndex('by_etapaOrigemId', (q) => q.eq('etapaOrigemId', etapaAtualHistorico.etapaId))
|
|
.collect();
|
|
|
|
const result = await Promise.all(
|
|
transicoes.map(async (t) => {
|
|
const etapa = await ctx.db.get(t.etapaDestinoId);
|
|
if (!etapa) return null;
|
|
return {
|
|
_id: etapa._id,
|
|
nome: etapa.nome,
|
|
codigo: etapa.codigo,
|
|
isPadrao: t.isPadrao
|
|
};
|
|
})
|
|
);
|
|
|
|
return result.filter((r): r is NonNullable<typeof r> => r !== null);
|
|
}
|
|
});
|
|
|
|
// ========== TRANSIÇÕES - MUTATIONS ==========
|
|
|
|
export const createTransicao = mutation({
|
|
args: {
|
|
etapaOrigemId: v.id('pedidoFluxoEtapa'),
|
|
etapaDestinoId: v.id('pedidoFluxoEtapa')
|
|
},
|
|
returns: v.id('pedidoFluxoTransicao'),
|
|
handler: async (ctx, args) => {
|
|
await getUsuarioAutenticado(ctx);
|
|
|
|
if (args.etapaOrigemId === args.etapaDestinoId) {
|
|
throw new Error('A etapa de origem e destino não podem ser iguais');
|
|
}
|
|
|
|
// Verificar se etapas existem
|
|
const origem = await ctx.db.get(args.etapaOrigemId);
|
|
const destino = await ctx.db.get(args.etapaDestinoId);
|
|
|
|
if (!origem) throw new Error('Etapa de origem não encontrada');
|
|
if (!destino) throw new Error('Etapa de destino não encontrada');
|
|
|
|
// Verificar se já existe esta transição
|
|
const existente = await ctx.db
|
|
.query('pedidoFluxoTransicao')
|
|
.withIndex('by_etapaOrigemId', (q) => q.eq('etapaOrigemId', args.etapaOrigemId))
|
|
.filter((q) => q.eq(q.field('etapaDestinoId'), args.etapaDestinoId))
|
|
.first();
|
|
|
|
if (existente) {
|
|
throw new Error('Esta transição já existe');
|
|
}
|
|
|
|
// Verificar se já existe alguma transição de saída para esta origem
|
|
const transicoesExistentes = await ctx.db
|
|
.query('pedidoFluxoTransicao')
|
|
.withIndex('by_etapaOrigemId', (q) => q.eq('etapaOrigemId', args.etapaOrigemId))
|
|
.collect();
|
|
|
|
// Se for a primeira transição, ela é a padrão
|
|
const isPadrao = transicoesExistentes.length === 0;
|
|
|
|
return await ctx.db.insert('pedidoFluxoTransicao', {
|
|
etapaOrigemId: args.etapaOrigemId,
|
|
etapaDestinoId: args.etapaDestinoId,
|
|
isPadrao,
|
|
criadoEm: Date.now()
|
|
});
|
|
}
|
|
});
|
|
|
|
export const deleteTransicao = mutation({
|
|
args: { id: v.id('pedidoFluxoTransicao') },
|
|
returns: v.null(),
|
|
handler: async (ctx, args) => {
|
|
await getUsuarioAutenticado(ctx);
|
|
|
|
const transicao = await ctx.db.get(args.id);
|
|
if (!transicao) {
|
|
throw new Error('Transição não encontrada');
|
|
}
|
|
|
|
await ctx.db.delete(args.id);
|
|
|
|
// Se era a transição padrão, definir outra como padrão
|
|
if (transicao.isPadrao) {
|
|
const outraTransicao = await ctx.db
|
|
.query('pedidoFluxoTransicao')
|
|
.withIndex('by_etapaOrigemId', (q) => q.eq('etapaOrigemId', transicao.etapaOrigemId))
|
|
.first();
|
|
|
|
if (outraTransicao) {
|
|
await ctx.db.patch(outraTransicao._id, { isPadrao: true });
|
|
}
|
|
}
|
|
|
|
return null;
|
|
}
|
|
});
|
|
|
|
export const setTransicaoPadrao = mutation({
|
|
args: { id: v.id('pedidoFluxoTransicao') },
|
|
returns: v.null(),
|
|
handler: async (ctx, args) => {
|
|
await getUsuarioAutenticado(ctx);
|
|
|
|
const transicao = await ctx.db.get(args.id);
|
|
if (!transicao) {
|
|
throw new Error('Transição não encontrada');
|
|
}
|
|
|
|
// Remover isPadrao de todas as transições da mesma origem
|
|
const todasTransicoes = await ctx.db
|
|
.query('pedidoFluxoTransicao')
|
|
.withIndex('by_etapaOrigemId', (q) => q.eq('etapaOrigemId', transicao.etapaOrigemId))
|
|
.collect();
|
|
|
|
for (const t of todasTransicoes) {
|
|
if (t._id !== args.id && t.isPadrao) {
|
|
await ctx.db.patch(t._id, { isPadrao: false });
|
|
}
|
|
}
|
|
|
|
// Definir esta como padrão
|
|
await ctx.db.patch(args.id, { isPadrao: true });
|
|
|
|
return null;
|
|
}
|
|
});
|
|
|
|
// ========== HISTÓRICO E TIMELINE ==========
|
|
|
|
export const getEtapasHistorico = query({
|
|
args: { pedidoId: v.id('pedidos') },
|
|
returns: v.array(
|
|
v.object({
|
|
_id: v.id('pedidoEtapasHistorico'),
|
|
_creationTime: v.number(),
|
|
pedidoId: v.id('pedidos'),
|
|
etapaId: v.id('pedidoFluxoEtapa'),
|
|
etapaNome: v.string(),
|
|
etapaCodigo: v.string(),
|
|
inicioData: v.number(),
|
|
fimData: v.optional(v.number()),
|
|
funcionarioId: v.optional(v.id('funcionarios')),
|
|
funcionarioNome: v.optional(v.string()),
|
|
atual: v.boolean()
|
|
})
|
|
),
|
|
handler: async (ctx, args) => {
|
|
const historico = await ctx.db
|
|
.query('pedidoEtapasHistorico')
|
|
.withIndex('by_pedidoId', (q) => q.eq('pedidoId', args.pedidoId))
|
|
.collect();
|
|
|
|
// Ordenar por inicioData
|
|
historico.sort((a, b) => a.inicioData - b.inicioData);
|
|
|
|
const result = await Promise.all(
|
|
historico.map(async (h) => {
|
|
const etapa = await ctx.db.get(h.etapaId);
|
|
let funcionarioNome: string | undefined;
|
|
if (h.funcionarioId) {
|
|
const funcionario = await ctx.db.get(h.funcionarioId);
|
|
funcionarioNome = funcionario?.nome;
|
|
}
|
|
return {
|
|
...h,
|
|
etapaNome: etapa?.nome ?? 'Desconhecido',
|
|
etapaCodigo: etapa?.codigo ?? 'desconhecido',
|
|
funcionarioNome
|
|
};
|
|
})
|
|
);
|
|
|
|
return result;
|
|
}
|
|
});
|
|
|
|
export const getPedidoTimeline = query({
|
|
args: { pedidoId: v.id('pedidos') },
|
|
returns: v.object({
|
|
passado: v.array(
|
|
v.object({
|
|
etapaId: v.id('pedidoFluxoEtapa'),
|
|
etapaNome: v.string(),
|
|
etapaCodigo: v.string(),
|
|
inicioData: v.number(),
|
|
fimData: v.optional(v.number()),
|
|
funcionarioNome: v.optional(v.string()),
|
|
atual: v.boolean(),
|
|
incluirNoTimeline: v.boolean()
|
|
})
|
|
),
|
|
futuro: v.array(
|
|
v.object({
|
|
etapaId: v.id('pedidoFluxoEtapa'),
|
|
etapaNome: v.string(),
|
|
etapaCodigo: v.string(),
|
|
dataPrevisao: v.number(),
|
|
incluirNoTimeline: v.boolean()
|
|
})
|
|
)
|
|
}),
|
|
handler: async (ctx, args) => {
|
|
// Buscar histórico passado
|
|
const historico = await ctx.db
|
|
.query('pedidoEtapasHistorico')
|
|
.withIndex('by_pedidoId', (q) => q.eq('pedidoId', args.pedidoId))
|
|
.collect();
|
|
|
|
historico.sort((a, b) => a.inicioData - b.inicioData);
|
|
|
|
const passado = await Promise.all(
|
|
historico.map(async (h) => {
|
|
const etapa = await ctx.db.get(h.etapaId);
|
|
let funcionarioNome: string | undefined;
|
|
if (h.funcionarioId) {
|
|
const funcionario = await ctx.db.get(h.funcionarioId);
|
|
funcionarioNome = funcionario?.nome;
|
|
}
|
|
return {
|
|
etapaId: h.etapaId,
|
|
etapaNome: etapa?.nome ?? 'Desconhecido',
|
|
etapaCodigo: etapa?.codigo ?? 'desconhecido',
|
|
inicioData: h.inicioData,
|
|
fimData: h.fimData,
|
|
funcionarioNome,
|
|
atual: h.atual,
|
|
incluirNoTimeline: etapa?.incluirNoTimeline ?? true
|
|
};
|
|
})
|
|
);
|
|
|
|
// Calcular previsão futura usando transições padrão
|
|
const futuro: {
|
|
etapaId: Id<'pedidoFluxoEtapa'>;
|
|
etapaNome: string;
|
|
etapaCodigo: string;
|
|
dataPrevisao: number;
|
|
incluirNoTimeline: boolean;
|
|
}[] = [];
|
|
|
|
const etapaAtualHistorico = historico.find((h) => h.atual);
|
|
if (etapaAtualHistorico) {
|
|
let etapaAtualId = etapaAtualHistorico.etapaId;
|
|
let dataPrevisao = Date.now();
|
|
|
|
// Calcular tempo decorrido na etapa atual
|
|
const etapaAtual = await ctx.db.get(etapaAtualId);
|
|
if (etapaAtual?.tempoEstimadoDias) {
|
|
dataPrevisao += etapaAtual.tempoEstimadoDias * 24 * 60 * 60 * 1000;
|
|
}
|
|
|
|
// Seguir transições padrão até não ter mais
|
|
const visitadas = new Set<string>();
|
|
let iteracoes = 0;
|
|
const MAX_ITERACOES = 20; // Evitar loop infinito
|
|
|
|
while (iteracoes < MAX_ITERACOES) {
|
|
iteracoes++;
|
|
|
|
if (visitadas.has(etapaAtualId)) break;
|
|
visitadas.add(etapaAtualId);
|
|
|
|
// Buscar transição padrão
|
|
const transicaoPadrao = await ctx.db
|
|
.query('pedidoFluxoTransicao')
|
|
.withIndex('by_etapaOrigemId_isPadrao', (q) =>
|
|
q.eq('etapaOrigemId', etapaAtualId).eq('isPadrao', true)
|
|
)
|
|
.first();
|
|
|
|
if (!transicaoPadrao) break;
|
|
|
|
const proximaEtapa = await ctx.db.get(transicaoPadrao.etapaDestinoId);
|
|
if (!proximaEtapa) break;
|
|
|
|
futuro.push({
|
|
etapaId: proximaEtapa._id,
|
|
etapaNome: proximaEtapa.nome,
|
|
etapaCodigo: proximaEtapa.codigo,
|
|
dataPrevisao,
|
|
incluirNoTimeline: proximaEtapa.incluirNoTimeline
|
|
});
|
|
|
|
// Atualizar para próxima iteração
|
|
if (proximaEtapa.tempoEstimadoDias) {
|
|
dataPrevisao += proximaEtapa.tempoEstimadoDias * 24 * 60 * 60 * 1000;
|
|
}
|
|
|
|
etapaAtualId = proximaEtapa._id;
|
|
}
|
|
}
|
|
|
|
return { passado, futuro };
|
|
}
|
|
});
|
|
|
|
// ========== MUDANÇA DE ETAPA ==========
|
|
|
|
export const mudarEtapa = mutation({
|
|
args: {
|
|
pedidoId: v.id('pedidos'),
|
|
novaEtapaId: v.id('pedidoFluxoEtapa'),
|
|
funcionarioId: v.optional(v.id('funcionarios'))
|
|
},
|
|
returns: v.id('pedidoEtapasHistorico'),
|
|
handler: async (ctx, args) => {
|
|
const usuario = await getUsuarioAutenticado(ctx);
|
|
|
|
const pedido = await ctx.db.get(args.pedidoId);
|
|
if (!pedido) {
|
|
throw new Error('Pedido não encontrado');
|
|
}
|
|
|
|
const novaEtapa = await ctx.db.get(args.novaEtapaId);
|
|
if (!novaEtapa) {
|
|
throw new Error('Etapa não encontrada');
|
|
}
|
|
|
|
const now = Date.now();
|
|
|
|
// Buscar etapa atual
|
|
const etapaAtualHistorico = await getEtapaAtualDoPedido(ctx, args.pedidoId);
|
|
|
|
if (etapaAtualHistorico) {
|
|
// Validar se a transição é permitida
|
|
const transicaoPermitida = await ctx.db
|
|
.query('pedidoFluxoTransicao')
|
|
.withIndex('by_etapaOrigemId', (q) => q.eq('etapaOrigemId', etapaAtualHistorico.etapaId))
|
|
.filter((q) => q.eq(q.field('etapaDestinoId'), args.novaEtapaId))
|
|
.first();
|
|
|
|
if (!transicaoPermitida) {
|
|
throw new Error('Transição não permitida para esta etapa');
|
|
}
|
|
|
|
// Finalizar etapa atual
|
|
await ctx.db.patch(etapaAtualHistorico._id, {
|
|
atual: false,
|
|
fimData: now
|
|
});
|
|
}
|
|
|
|
// Criar novo registro de etapa
|
|
const novoHistoricoId = await ctx.db.insert('pedidoEtapasHistorico', {
|
|
pedidoId: args.pedidoId,
|
|
etapaId: args.novaEtapaId,
|
|
inicioData: now,
|
|
funcionarioId: args.funcionarioId,
|
|
atual: true
|
|
});
|
|
|
|
// Registrar no histórico de pedidos
|
|
await ctx.db.insert('historicoPedidos', {
|
|
pedidoId: args.pedidoId,
|
|
usuarioId: usuario._id,
|
|
acao: 'alteracao_etapa',
|
|
detalhes: JSON.stringify({
|
|
novaEtapa: novaEtapa.codigo,
|
|
novaEtapaNome: novaEtapa.nome,
|
|
funcionarioId: args.funcionarioId
|
|
}),
|
|
data: now
|
|
});
|
|
|
|
return novoHistoricoId;
|
|
}
|
|
});
|
|
|
|
export const iniciarFluxoPedido = mutation({
|
|
args: {
|
|
pedidoId: v.id('pedidos')
|
|
},
|
|
returns: v.id('pedidoEtapasHistorico'),
|
|
handler: async (ctx, args) => {
|
|
const usuario = await getUsuarioAutenticado(ctx);
|
|
|
|
const pedido = await ctx.db.get(args.pedidoId);
|
|
if (!pedido) {
|
|
throw new Error('Pedido não encontrado');
|
|
}
|
|
|
|
// Verificar se já tem histórico
|
|
const historicoExistente = await ctx.db
|
|
.query('pedidoEtapasHistorico')
|
|
.withIndex('by_pedidoId', (q) => q.eq('pedidoId', args.pedidoId))
|
|
.first();
|
|
|
|
if (historicoExistente) {
|
|
throw new Error('Este pedido já possui histórico de etapas');
|
|
}
|
|
|
|
// Buscar primeira etapa do fluxo
|
|
const primeiraEtapa = await ctx.db.query('pedidoFluxoEtapa').withIndex('by_ordem').first();
|
|
|
|
if (!primeiraEtapa) {
|
|
throw new Error('Nenhuma etapa configurada no fluxo');
|
|
}
|
|
|
|
const now = Date.now();
|
|
|
|
// Criar primeiro registro
|
|
const historicoId = await ctx.db.insert('pedidoEtapasHistorico', {
|
|
pedidoId: args.pedidoId,
|
|
etapaId: primeiraEtapa._id,
|
|
inicioData: now,
|
|
atual: true
|
|
});
|
|
|
|
// Registrar no histórico
|
|
await ctx.db.insert('historicoPedidos', {
|
|
pedidoId: args.pedidoId,
|
|
usuarioId: usuario._id,
|
|
acao: 'inicio_fluxo',
|
|
detalhes: JSON.stringify({
|
|
etapa: primeiraEtapa.codigo,
|
|
etapaNome: primeiraEtapa.nome
|
|
}),
|
|
data: now
|
|
});
|
|
|
|
return historicoId;
|
|
}
|
|
});
|
|
|
|
export const atribuirFuncionario = mutation({
|
|
args: {
|
|
pedidoId: v.id('pedidos'),
|
|
funcionarioId: v.id('funcionarios')
|
|
},
|
|
returns: v.null(),
|
|
handler: async (ctx, args) => {
|
|
await getUsuarioAutenticado(ctx);
|
|
|
|
const etapaAtual = await getEtapaAtualDoPedido(ctx, args.pedidoId);
|
|
if (!etapaAtual) {
|
|
throw new Error('Pedido não possui etapa atual');
|
|
}
|
|
|
|
const funcionario = await ctx.db.get(args.funcionarioId);
|
|
if (!funcionario) {
|
|
throw new Error('Funcionário não encontrado');
|
|
}
|
|
|
|
await ctx.db.patch(etapaAtual._id, {
|
|
funcionarioId: args.funcionarioId
|
|
});
|
|
|
|
return null;
|
|
}
|
|
});
|
|
|
|
// ========== QUERY PARA OBTER ETAPA ATUAL ==========
|
|
|
|
export const getEtapaAtual = query({
|
|
args: { pedidoId: v.id('pedidos') },
|
|
returns: v.union(
|
|
v.object({
|
|
_id: v.id('pedidoEtapasHistorico'),
|
|
etapaId: v.id('pedidoFluxoEtapa'),
|
|
etapaNome: v.string(),
|
|
etapaCodigo: v.string(),
|
|
setorId: v.optional(v.id('setores')),
|
|
setorNome: v.optional(v.string()),
|
|
inicioData: v.number(),
|
|
funcionarioId: v.optional(v.id('funcionarios')),
|
|
funcionarioNome: v.optional(v.string())
|
|
}),
|
|
v.null()
|
|
),
|
|
handler: async (ctx, args) => {
|
|
const etapaAtualHistorico = await getEtapaAtualDoPedido(ctx, args.pedidoId);
|
|
if (!etapaAtualHistorico) return null;
|
|
|
|
const etapa = await ctx.db.get(etapaAtualHistorico.etapaId);
|
|
if (!etapa) return null;
|
|
|
|
let setorNome: string | undefined;
|
|
if (etapa.setorId) {
|
|
const setor = await ctx.db.get(etapa.setorId);
|
|
setorNome = setor?.nome;
|
|
}
|
|
|
|
let funcionarioNome: string | undefined;
|
|
if (etapaAtualHistorico.funcionarioId) {
|
|
const funcionario = await ctx.db.get(etapaAtualHistorico.funcionarioId);
|
|
funcionarioNome = funcionario?.nome;
|
|
}
|
|
|
|
return {
|
|
_id: etapaAtualHistorico._id,
|
|
etapaId: etapa._id,
|
|
etapaNome: etapa.nome,
|
|
etapaCodigo: etapa.codigo,
|
|
setorId: etapa.setorId,
|
|
setorNome,
|
|
inicioData: etapaAtualHistorico.inicioData,
|
|
funcionarioId: etapaAtualHistorico.funcionarioId,
|
|
funcionarioNome
|
|
};
|
|
}
|
|
});
|