killer-cf
3a32f5e4eb
- Deleted the `autenticacao.ts` file to streamline the authentication process. - Updated the `auth.ts` file to include new functions for user management and password updates. - Modified the schema to enforce the presence of `authId` for users, ensuring integration with Better Auth. - Refactored the seed process to create users with Better Auth integration, enhancing user management capabilities. - Cleaned up the `usuarios.ts` file to utilize the new authentication functions and improve code clarity.
1084 lines
30 KiB
TypeScript
1084 lines
30 KiB
TypeScript
import { v } from "convex/values";
|
|
import { mutation, query } from "./_generated/server";
|
|
import { hashPassword } from "./auth/utils";
|
|
import { registrarAtividade } from "./logsAtividades";
|
|
import { Id, Doc } from "./_generated/dataModel";
|
|
import type { QueryCtx, MutationCtx } from "./_generated/server";
|
|
import { createAuthUser, getCurrentUserFunction } from "./auth";
|
|
|
|
/**
|
|
* Helper para obter a matrícula do usuário (do funcionário se houver)
|
|
*/
|
|
async function obterMatriculaUsuario(
|
|
ctx: QueryCtx,
|
|
usuario: Doc<"usuarios">
|
|
): Promise<string | undefined> {
|
|
if (usuario.funcionarioId) {
|
|
const funcionario = await ctx.db.get(usuario.funcionarioId);
|
|
return funcionario?.matricula;
|
|
}
|
|
return undefined;
|
|
}
|
|
|
|
/**
|
|
* Associar funcionário a um usuário
|
|
*/
|
|
export const associarFuncionario = mutation({
|
|
args: {
|
|
usuarioId: v.id("usuarios"),
|
|
funcionarioId: v.id("funcionarios"),
|
|
},
|
|
returns: v.object({ sucesso: v.boolean() }),
|
|
handler: async (ctx, args) => {
|
|
// Verificar se o funcionário existe
|
|
const funcionario = await ctx.db.get(args.funcionarioId);
|
|
if (!funcionario) {
|
|
throw new Error("Funcionário não encontrado");
|
|
}
|
|
|
|
// Verificar se o funcionário já está associado a outro usuário
|
|
const usuarioExistente = await ctx.db
|
|
.query("usuarios")
|
|
.withIndex("by_funcionarioId", (q) =>
|
|
q.eq("funcionarioId", args.funcionarioId)
|
|
)
|
|
.first();
|
|
|
|
if (usuarioExistente && usuarioExistente._id !== args.usuarioId) {
|
|
const matricula = await obterMatriculaUsuario(ctx, usuarioExistente);
|
|
throw new Error(
|
|
`Este funcionário já está associado ao usuário: ${
|
|
usuarioExistente.nome
|
|
}${matricula ? ` (${matricula})` : ""}`
|
|
);
|
|
}
|
|
|
|
// Associar funcionário ao usuário
|
|
await ctx.db.patch(args.usuarioId, {
|
|
funcionarioId: args.funcionarioId,
|
|
});
|
|
|
|
return { sucesso: true };
|
|
},
|
|
});
|
|
|
|
/**
|
|
* Desassociar funcionário de um usuário
|
|
*/
|
|
export const desassociarFuncionario = mutation({
|
|
args: {
|
|
usuarioId: v.id("usuarios"),
|
|
},
|
|
returns: v.object({ sucesso: v.boolean() }),
|
|
handler: async (ctx, args) => {
|
|
await ctx.db.patch(args.usuarioId, {
|
|
funcionarioId: undefined,
|
|
});
|
|
|
|
return { sucesso: true };
|
|
},
|
|
});
|
|
|
|
/**
|
|
* Criar novo usuário (apenas TI)
|
|
*/
|
|
export const criar = mutation({
|
|
args: {
|
|
nome: v.string(),
|
|
email: v.string(),
|
|
roleId: v.id("roles"),
|
|
funcionarioId: v.optional(v.id("funcionarios")),
|
|
senhaInicial: v.string(),
|
|
},
|
|
returns: v.union(
|
|
v.object({ sucesso: v.literal(true), usuarioId: v.id("usuarios") }),
|
|
v.object({ sucesso: v.literal(false), erro: v.string() })
|
|
),
|
|
handler: async (ctx, args) => {
|
|
// Verificar se email já existe
|
|
const emailExistente = await ctx.db
|
|
.query("usuarios")
|
|
.withIndex("by_email", (q) => q.eq("email", args.email))
|
|
.first();
|
|
|
|
if (emailExistente) {
|
|
return { sucesso: false as const, erro: "E-mail já cadastrado" };
|
|
}
|
|
|
|
const senhaTemporaria = args.senhaInicial;
|
|
|
|
const authUserId = await createAuthUser(ctx, {
|
|
nome: args.nome,
|
|
email: args.email,
|
|
password: senhaTemporaria,
|
|
});
|
|
|
|
// Criar usuário
|
|
const usuarioId = await ctx.db.insert("usuarios", {
|
|
authId: authUserId,
|
|
nome: args.nome,
|
|
email: args.email,
|
|
funcionarioId: args.funcionarioId,
|
|
roleId: args.roleId,
|
|
ativo: true,
|
|
primeiroAcesso: true,
|
|
criadoEm: Date.now(),
|
|
atualizadoEm: Date.now(),
|
|
});
|
|
|
|
return { sucesso: true as const, usuarioId };
|
|
},
|
|
});
|
|
|
|
/**
|
|
* Listar todos os usuários com filtros
|
|
*/
|
|
export const listar = query({
|
|
args: {
|
|
setor: v.optional(v.string()),
|
|
matricula: v.optional(v.string()),
|
|
ativo: v.optional(v.boolean()),
|
|
},
|
|
handler: async (ctx, args) => {
|
|
let usuarios = await ctx.db.query("usuarios").collect();
|
|
|
|
// Filtrar por matrícula (buscar no funcionário)
|
|
if (args.matricula) {
|
|
const usuariosComMatricula = await Promise.all(
|
|
usuarios.map(async (u) => {
|
|
const matricula = await obterMatriculaUsuario(ctx, u);
|
|
return { usuario: u, matricula };
|
|
})
|
|
);
|
|
usuarios = usuariosComMatricula
|
|
.filter(({ matricula }) => matricula?.includes(args.matricula!))
|
|
.map(({ usuario }) => usuario);
|
|
}
|
|
|
|
// Filtrar por ativo
|
|
if (args.ativo !== undefined) {
|
|
usuarios = usuarios.filter((u) => u.ativo === args.ativo);
|
|
}
|
|
|
|
// Buscar roles e funcionários
|
|
const resultado = [];
|
|
const usuariosSemRole: Array<{
|
|
nome: string;
|
|
matricula: string;
|
|
roleId: Id<"roles">;
|
|
}> = [];
|
|
|
|
for (const usuario of usuarios) {
|
|
try {
|
|
const role = await ctx.db.get(usuario.roleId);
|
|
|
|
// Se a role não existe, criar uma role de erro mas ainda incluir o usuário
|
|
if (!role) {
|
|
const matricula = await obterMatriculaUsuario(ctx, usuario);
|
|
usuariosSemRole.push({
|
|
nome: usuario.nome,
|
|
matricula: matricula || "N/A",
|
|
roleId: usuario.roleId,
|
|
});
|
|
|
|
// Filtrar por setor - se filtro está ativo e role não existe, pular
|
|
if (args.setor) {
|
|
continue;
|
|
}
|
|
|
|
// Incluir usuário com role de erro
|
|
let funcionario = undefined;
|
|
if (usuario.funcionarioId) {
|
|
try {
|
|
const func = await ctx.db.get(usuario.funcionarioId);
|
|
if (func) {
|
|
funcionario = {
|
|
_id: func._id,
|
|
nome: func.nome,
|
|
matricula: func.matricula,
|
|
descricaoCargo: func.descricaoCargo,
|
|
simboloTipo: func.simboloTipo,
|
|
};
|
|
}
|
|
} catch (error) {
|
|
console.error(
|
|
`Erro ao buscar funcionário ${usuario.funcionarioId} para usuário ${usuario._id}:`,
|
|
error
|
|
);
|
|
}
|
|
}
|
|
|
|
const matriculaUsuario = await obterMatriculaUsuario(ctx, usuario);
|
|
|
|
// Criar role de erro (sem _creationTime pois a role não existe)
|
|
resultado.push({
|
|
_id: usuario._id,
|
|
matricula: matriculaUsuario,
|
|
nome: usuario.nome,
|
|
email: usuario.email,
|
|
ativo: usuario.ativo,
|
|
bloqueado: usuario.bloqueado,
|
|
motivoBloqueio: usuario.motivoBloqueio,
|
|
primeiroAcesso: usuario.primeiroAcesso,
|
|
ultimoAcesso: usuario.ultimoAcesso,
|
|
criadoEm: usuario.criadoEm,
|
|
role: {
|
|
_id: usuario.roleId,
|
|
descricao: "Perfil não encontrado" as const,
|
|
nome: "erro_role_ausente" as const,
|
|
nivel: 999 as const,
|
|
erro: true as const,
|
|
},
|
|
funcionario,
|
|
avisos: [
|
|
{
|
|
tipo: "erro" as const,
|
|
mensagem: `Perfil de acesso (ID: ${usuario.roleId}) não encontrado. Este usuário precisa ter seu perfil reatribuído.`,
|
|
},
|
|
],
|
|
});
|
|
continue;
|
|
}
|
|
|
|
// Filtrar por setor
|
|
if (args.setor && role.setor !== args.setor) {
|
|
continue;
|
|
}
|
|
|
|
// Buscar funcionário associado
|
|
let funcionario = undefined;
|
|
if (usuario.funcionarioId) {
|
|
try {
|
|
const func = await ctx.db.get(usuario.funcionarioId);
|
|
if (func) {
|
|
funcionario = {
|
|
_id: func._id,
|
|
nome: func.nome,
|
|
matricula: func.matricula,
|
|
descricaoCargo: func.descricaoCargo,
|
|
simboloTipo: func.simboloTipo,
|
|
};
|
|
}
|
|
} catch (error) {
|
|
console.error(
|
|
`Erro ao buscar funcionário ${usuario.funcionarioId} para usuário ${usuario._id}:`,
|
|
error
|
|
);
|
|
}
|
|
}
|
|
|
|
// Construir objeto role - incluir _creationTime se existir (campo automático do Convex)
|
|
const roleObj = {
|
|
_id: role._id,
|
|
descricao: role.descricao,
|
|
nome: role.nome,
|
|
nivel: role.nivel,
|
|
...(role.criadoPor !== undefined && { criadoPor: role.criadoPor }),
|
|
...(role.customizado !== undefined && {
|
|
customizado: role.customizado,
|
|
}),
|
|
...(role.editavel !== undefined && { editavel: role.editavel }),
|
|
...(role.setor !== undefined && { setor: role.setor }),
|
|
};
|
|
|
|
const matriculaUsuario = await obterMatriculaUsuario(ctx, usuario);
|
|
|
|
resultado.push({
|
|
_id: usuario._id,
|
|
matricula: matriculaUsuario,
|
|
nome: usuario.nome,
|
|
email: usuario.email,
|
|
ativo: usuario.ativo,
|
|
bloqueado: usuario.bloqueado,
|
|
motivoBloqueio: usuario.motivoBloqueio,
|
|
primeiroAcesso: usuario.primeiroAcesso,
|
|
ultimoAcesso: usuario.ultimoAcesso,
|
|
criadoEm: usuario.criadoEm,
|
|
role: roleObj,
|
|
funcionario,
|
|
});
|
|
} catch (error) {
|
|
console.error(`Erro ao processar usuário ${usuario._id}:`, error);
|
|
// Continua processando outros usuários mesmo se houver erro em um
|
|
}
|
|
}
|
|
|
|
// Log de usuários sem role para depuração
|
|
if (usuariosSemRole.length > 0) {
|
|
console.warn(
|
|
`⚠️ Encontrados ${usuariosSemRole.length} usuário(s) com perfil ausente:`,
|
|
usuariosSemRole.map(
|
|
(u) =>
|
|
`${u.nome}${
|
|
u.matricula !== "N/A" ? ` (${u.matricula})` : ""
|
|
} - RoleID: ${u.roleId}`
|
|
)
|
|
);
|
|
}
|
|
|
|
return resultado;
|
|
},
|
|
});
|
|
|
|
/**
|
|
* Ativar/Desativar usuário
|
|
*/
|
|
export const alterarStatus = mutation({
|
|
args: {
|
|
usuarioId: v.id("usuarios"),
|
|
ativo: v.boolean(),
|
|
},
|
|
returns: v.null(),
|
|
handler: async (ctx, args) => {
|
|
await ctx.db.patch(args.usuarioId, {
|
|
ativo: args.ativo,
|
|
atualizadoEm: Date.now(),
|
|
});
|
|
|
|
// Se desativar, desativar todas as sessões
|
|
if (!args.ativo) {
|
|
const sessoes = await ctx.db
|
|
.query("sessoes")
|
|
.withIndex("by_usuario", (q) => q.eq("usuarioId", args.usuarioId))
|
|
.collect();
|
|
|
|
for (const sessao of sessoes) {
|
|
await ctx.db.patch(sessao._id, { ativo: false });
|
|
}
|
|
}
|
|
|
|
return null;
|
|
},
|
|
});
|
|
|
|
/**
|
|
* Resetar senha do usuário
|
|
*/
|
|
// export const resetarSenha = mutation({
|
|
// args: {
|
|
// usuarioId: v.id("usuarios"),
|
|
// novaSenha: v.string(),
|
|
// },
|
|
// returns: v.null(),
|
|
// handler: async (ctx, args) => {
|
|
// const senhaHash = await hashPassword(args.novaSenha);
|
|
|
|
// await ctx.db.patch(args.usuarioId, {
|
|
// senhaHash,
|
|
// primeiroAcesso: true,
|
|
// atualizadoEm: Date.now(),
|
|
// });
|
|
|
|
// // Desativar todas as sessões
|
|
// const sessoes = await ctx.db
|
|
// .query("sessoes")
|
|
// .withIndex("by_usuario", (q) => q.eq("usuarioId", args.usuarioId))
|
|
// .collect();
|
|
|
|
// for (const sessao of sessoes) {
|
|
// await ctx.db.patch(sessao._id, { ativo: false });
|
|
// }
|
|
|
|
// return null;
|
|
// },
|
|
// });
|
|
|
|
/**
|
|
* Excluir usuário
|
|
*/
|
|
export const excluir = mutation({
|
|
args: {
|
|
usuarioId: v.id("usuarios"),
|
|
},
|
|
returns: v.null(),
|
|
handler: async (ctx, args) => {
|
|
// Excluir sessões
|
|
const sessoes = await ctx.db
|
|
.query("sessoes")
|
|
.withIndex("by_usuario", (q) => q.eq("usuarioId", args.usuarioId))
|
|
.collect();
|
|
|
|
for (const sessao of sessoes) {
|
|
await ctx.db.delete(sessao._id);
|
|
}
|
|
|
|
// Excluir usuário
|
|
await ctx.db.delete(args.usuarioId);
|
|
|
|
return null;
|
|
},
|
|
});
|
|
|
|
/**
|
|
* Ativar usuário
|
|
*/
|
|
export const ativar = mutation({
|
|
args: {
|
|
id: v.id("usuarios"),
|
|
},
|
|
returns: v.null(),
|
|
handler: async (ctx, args) => {
|
|
await ctx.db.patch(args.id, {
|
|
ativo: true,
|
|
atualizadoEm: Date.now(),
|
|
});
|
|
return null;
|
|
},
|
|
});
|
|
|
|
/**
|
|
* Desativar usuário
|
|
*/
|
|
export const desativar = mutation({
|
|
args: {
|
|
id: v.id("usuarios"),
|
|
},
|
|
returns: v.null(),
|
|
handler: async (ctx, args) => {
|
|
await ctx.db.patch(args.id, {
|
|
ativo: false,
|
|
atualizadoEm: Date.now(),
|
|
});
|
|
|
|
// Desativar todas as sessões
|
|
const sessoes = await ctx.db
|
|
.query("sessoes")
|
|
.withIndex("by_usuario", (q) => q.eq("usuarioId", args.id))
|
|
.collect();
|
|
|
|
for (const sessao of sessoes) {
|
|
await ctx.db.patch(sessao._id, { ativo: false });
|
|
}
|
|
|
|
return null;
|
|
},
|
|
});
|
|
|
|
/**
|
|
* Alterar role de um usuário
|
|
*/
|
|
export const alterarRole = mutation({
|
|
args: {
|
|
usuarioId: v.id("usuarios"),
|
|
novaRoleId: v.id("roles"),
|
|
},
|
|
returns: v.null(),
|
|
handler: async (ctx, args) => {
|
|
// Verificar se a role existe
|
|
const role = await ctx.db.get(args.novaRoleId);
|
|
if (!role) {
|
|
throw new Error("Role não encontrada");
|
|
}
|
|
|
|
// Atualizar usuário
|
|
await ctx.db.patch(args.usuarioId, {
|
|
roleId: args.novaRoleId,
|
|
atualizadoEm: Date.now(),
|
|
});
|
|
|
|
return null;
|
|
},
|
|
});
|
|
|
|
/**
|
|
* Atualizar perfil do usuário (foto, avatar, setor, status, preferências)
|
|
*/
|
|
export const atualizarPerfil = mutation({
|
|
args: {
|
|
avatar: v.optional(v.string()),
|
|
fotoPerfil: v.optional(v.id("_storage")),
|
|
setor: v.optional(v.string()),
|
|
statusMensagem: v.optional(v.string()),
|
|
statusPresenca: v.optional(
|
|
v.union(
|
|
v.literal("online"),
|
|
v.literal("offline"),
|
|
v.literal("ausente"),
|
|
v.literal("externo"),
|
|
v.literal("em_reuniao")
|
|
)
|
|
),
|
|
notificacoesAtivadas: v.optional(v.boolean()),
|
|
somNotificacao: v.optional(v.boolean()),
|
|
},
|
|
returns: v.null(),
|
|
handler: async (ctx, args) => {
|
|
// TENTAR BETTER AUTH PRIMEIRO
|
|
const identity = await ctx.auth.getUserIdentity();
|
|
|
|
let usuarioAtual = null;
|
|
|
|
if (identity && identity.email) {
|
|
// Buscar por email (Better Auth)
|
|
usuarioAtual = await ctx.db
|
|
.query("usuarios")
|
|
.withIndex("by_email", (q) => q.eq("email", identity.email!))
|
|
.first();
|
|
}
|
|
|
|
if (!usuarioAtual) throw new Error("Usuário não encontrado");
|
|
|
|
// Validar statusMensagem (max 100 chars)
|
|
if (args.statusMensagem && args.statusMensagem.length > 100) {
|
|
throw new Error("Mensagem de status deve ter no máximo 100 caracteres");
|
|
}
|
|
|
|
// Atualizar apenas os campos fornecidos
|
|
const updates: Partial<Doc<"usuarios">> & { atualizadoEm: number } = {
|
|
atualizadoEm: Date.now(),
|
|
};
|
|
|
|
if (args.avatar !== undefined) updates.avatar = args.avatar;
|
|
if (args.fotoPerfil !== undefined) updates.fotoPerfil = args.fotoPerfil;
|
|
if (args.setor !== undefined) updates.setor = args.setor;
|
|
if (args.statusMensagem !== undefined)
|
|
updates.statusMensagem = args.statusMensagem;
|
|
if (args.statusPresenca !== undefined) {
|
|
updates.statusPresenca = args.statusPresenca;
|
|
updates.ultimaAtividade = Date.now();
|
|
}
|
|
if (args.notificacoesAtivadas !== undefined)
|
|
updates.notificacoesAtivadas = args.notificacoesAtivadas;
|
|
if (args.somNotificacao !== undefined)
|
|
updates.somNotificacao = args.somNotificacao;
|
|
|
|
await ctx.db.patch(usuarioAtual._id, updates);
|
|
|
|
return null;
|
|
},
|
|
});
|
|
|
|
/**
|
|
* Obter perfil do usuário atual
|
|
*/
|
|
export const obterPerfil = query({
|
|
args: {},
|
|
returns: v.union(
|
|
v.object({
|
|
_id: v.id("usuarios"),
|
|
nome: v.string(),
|
|
email: v.string(),
|
|
matricula: v.optional(v.string()),
|
|
funcionarioId: v.optional(v.id("funcionarios")),
|
|
avatar: v.optional(v.string()),
|
|
fotoPerfil: v.optional(v.id("_storage")),
|
|
fotoPerfilUrl: v.union(v.string(), v.null()),
|
|
setor: v.optional(v.string()),
|
|
statusMensagem: v.optional(v.string()),
|
|
statusPresenca: v.optional(
|
|
v.union(
|
|
v.literal("online"),
|
|
v.literal("offline"),
|
|
v.literal("ausente"),
|
|
v.literal("externo"),
|
|
v.literal("em_reuniao")
|
|
)
|
|
),
|
|
notificacoesAtivadas: v.boolean(),
|
|
somNotificacao: v.boolean(),
|
|
}),
|
|
v.null()
|
|
),
|
|
handler: async (ctx) => {
|
|
const identity = await ctx.auth.getUserIdentity();
|
|
console.log("Identity:", identity ? "encontrado" : "null");
|
|
|
|
let usuarioAtual = null;
|
|
|
|
if (identity && identity.email) {
|
|
console.log("Tentando buscar por email:", identity.email);
|
|
// Buscar por email (Better Auth)
|
|
usuarioAtual = await ctx.db
|
|
.query("usuarios")
|
|
.withIndex("by_email", (q) => q.eq("email", identity.email!))
|
|
.first();
|
|
}
|
|
|
|
if (!usuarioAtual) {
|
|
return null;
|
|
}
|
|
|
|
console.log("✅ Usuário encontrado:", usuarioAtual.nome);
|
|
|
|
// Buscar fotoPerfil URL se existir
|
|
let fotoPerfilUrl = null;
|
|
if (usuarioAtual.fotoPerfil) {
|
|
fotoPerfilUrl = await ctx.storage.getUrl(usuarioAtual.fotoPerfil);
|
|
}
|
|
|
|
const matricula = await obterMatriculaUsuario(ctx, usuarioAtual);
|
|
|
|
return {
|
|
_id: usuarioAtual._id,
|
|
nome: usuarioAtual.nome,
|
|
email: usuarioAtual.email,
|
|
matricula: matricula || undefined,
|
|
funcionarioId: usuarioAtual.funcionarioId,
|
|
avatar: usuarioAtual.avatar,
|
|
fotoPerfil: usuarioAtual.fotoPerfil,
|
|
fotoPerfilUrl,
|
|
setor: usuarioAtual.setor,
|
|
statusMensagem: usuarioAtual.statusMensagem,
|
|
statusPresenca: usuarioAtual.statusPresenca,
|
|
notificacoesAtivadas: usuarioAtual.notificacoesAtivadas ?? true,
|
|
somNotificacao: usuarioAtual.somNotificacao ?? true,
|
|
};
|
|
},
|
|
});
|
|
|
|
/**
|
|
* Listar todos usuários para o chat (com avatar, foto e status)
|
|
*/
|
|
export const listarParaChat = query({
|
|
args: {},
|
|
returns: v.array(
|
|
v.object({
|
|
_id: v.id("usuarios"),
|
|
nome: v.string(),
|
|
email: v.string(),
|
|
matricula: v.optional(v.string()),
|
|
avatar: v.optional(v.string()),
|
|
fotoPerfil: v.optional(v.id("_storage")),
|
|
fotoPerfilUrl: v.union(v.string(), v.null()),
|
|
statusPresenca: v.optional(
|
|
v.union(
|
|
v.literal("online"),
|
|
v.literal("offline"),
|
|
v.literal("ausente"),
|
|
v.literal("externo"),
|
|
v.literal("em_reuniao")
|
|
)
|
|
),
|
|
statusMensagem: v.optional(v.string()),
|
|
ultimaAtividade: v.optional(v.number()),
|
|
})
|
|
),
|
|
handler: async (ctx) => {
|
|
// Obter usuário autenticado usando função helper compartilhada
|
|
const usuarioAtual = await getCurrentUserFunction(ctx);
|
|
if (!usuarioAtual) {
|
|
return [];
|
|
}
|
|
|
|
// Buscar todos os usuários ativos
|
|
const usuarios = await ctx.db
|
|
.query("usuarios")
|
|
.filter((q) => q.eq(q.field("ativo"), true))
|
|
.collect();
|
|
|
|
// Filtrar o usuário atual da lista apenas se conseguimos identificá-lo com certeza
|
|
// Se não conseguimos identificar (usuarioAtual é null), retornar todos
|
|
// O frontend fará um filtro adicional usando obterPerfil como camada de segurança
|
|
const usuariosFiltrados = usuarioAtual
|
|
? usuarios.filter((u) => u._id !== usuarioAtual._id)
|
|
: usuarios;
|
|
|
|
// Buscar foto de perfil URL para cada usuário
|
|
const usuariosComFoto = await Promise.all(
|
|
usuariosFiltrados.map(async (usuario) => {
|
|
let fotoPerfilUrl = null;
|
|
if (usuario.fotoPerfil) {
|
|
fotoPerfilUrl = await ctx.storage.getUrl(usuario.fotoPerfil);
|
|
}
|
|
|
|
const matricula = await obterMatriculaUsuario(ctx, usuario);
|
|
|
|
return {
|
|
_id: usuario._id,
|
|
nome: usuario.nome,
|
|
email: usuario.email,
|
|
matricula: matricula || undefined,
|
|
avatar: usuario.avatar,
|
|
fotoPerfil: usuario.fotoPerfil,
|
|
fotoPerfilUrl,
|
|
statusPresenca: usuario.statusPresenca || "offline",
|
|
statusMensagem: usuario.statusMensagem,
|
|
ultimaAtividade: usuario.ultimaAtividade,
|
|
};
|
|
})
|
|
);
|
|
|
|
return usuariosComFoto;
|
|
},
|
|
});
|
|
|
|
/**
|
|
* Gera URL para upload de foto de perfil
|
|
*/
|
|
export const uploadFotoPerfil = mutation({
|
|
args: {},
|
|
returns: v.string(),
|
|
handler: async (ctx) => {
|
|
// TENTAR BETTER AUTH PRIMEIRO
|
|
const identity = await ctx.auth.getUserIdentity();
|
|
|
|
let usuarioAtual = null;
|
|
|
|
if (identity && identity.email) {
|
|
// Buscar por email (Better Auth)
|
|
usuarioAtual = await ctx.db
|
|
.query("usuarios")
|
|
.withIndex("by_email", (q) => q.eq("email", identity.email!))
|
|
.first();
|
|
}
|
|
|
|
// SE NÃO ENCONTROU, BUSCAR POR SESSÃO ATIVA (Sistema customizado)
|
|
if (!usuarioAtual) {
|
|
const sessaoAtiva = await ctx.db
|
|
.query("sessoes")
|
|
.filter((q) => q.eq(q.field("ativo"), true))
|
|
.order("desc")
|
|
.first();
|
|
|
|
if (sessaoAtiva) {
|
|
usuarioAtual = await ctx.db.get(sessaoAtiva.usuarioId);
|
|
}
|
|
}
|
|
|
|
if (!usuarioAtual) throw new Error("Usuário não autenticado");
|
|
|
|
return await ctx.storage.generateUploadUrl();
|
|
},
|
|
});
|
|
|
|
// ==================== GESTÃO AVANÇADA DE USUÁRIOS (TI_MASTER) ====================
|
|
|
|
/**
|
|
* Bloquear usuário (apenas TI_MASTER)
|
|
*/
|
|
export const bloquearUsuario = mutation({
|
|
args: {
|
|
usuarioId: v.id("usuarios"),
|
|
motivo: v.string(),
|
|
bloqueadoPorId: v.id("usuarios"),
|
|
},
|
|
returns: v.union(
|
|
v.object({ sucesso: v.literal(true) }),
|
|
v.object({ sucesso: v.literal(false), erro: v.string() })
|
|
),
|
|
handler: async (ctx, args) => {
|
|
const usuarioAtual = await getCurrentUserFunction(ctx);
|
|
if (!usuarioAtual) {
|
|
return { sucesso: false as const, erro: "Usuário não autenticado" };
|
|
}
|
|
|
|
const usuario = await ctx.db.get(args.usuarioId);
|
|
if (!usuario) {
|
|
return { sucesso: false as const, erro: "Usuário não encontrado" };
|
|
}
|
|
|
|
// Atualizar usuário como bloqueado
|
|
await ctx.db.patch(args.usuarioId, {
|
|
bloqueado: true,
|
|
motivoBloqueio: args.motivo,
|
|
dataBloqueio: Date.now(),
|
|
atualizadoEm: Date.now(),
|
|
});
|
|
|
|
// Registrar no histórico de bloqueios
|
|
await ctx.db.insert("bloqueiosUsuarios", {
|
|
usuarioId: args.usuarioId,
|
|
motivo: args.motivo,
|
|
bloqueadoPor: args.bloqueadoPorId,
|
|
dataInicio: Date.now(),
|
|
ativo: true,
|
|
});
|
|
|
|
// Desativar todas as sessões ativas do usuário
|
|
const sessoes = await ctx.db
|
|
.query("sessoes")
|
|
.withIndex("by_usuario", (q) => q.eq("usuarioId", args.usuarioId))
|
|
.filter((q) => q.eq(q.field("ativo"), true))
|
|
.collect();
|
|
|
|
for (const sessao of sessoes) {
|
|
await ctx.db.patch(sessao._id, { ativo: false });
|
|
}
|
|
|
|
// Log de atividade
|
|
await registrarAtividade(
|
|
ctx,
|
|
args.bloqueadoPorId,
|
|
"bloquear",
|
|
"usuarios",
|
|
JSON.stringify({ usuarioId: args.usuarioId, motivo: args.motivo }),
|
|
args.usuarioId
|
|
);
|
|
|
|
return { sucesso: true as const };
|
|
},
|
|
});
|
|
|
|
/**
|
|
* Desbloquear usuário (apenas TI_MASTER)
|
|
*/
|
|
export const desbloquearUsuario = mutation({
|
|
args: {
|
|
usuarioId: v.id("usuarios"),
|
|
desbloqueadoPorId: v.id("usuarios"),
|
|
},
|
|
returns: v.union(
|
|
v.object({ sucesso: v.literal(true) }),
|
|
v.object({ sucesso: v.literal(false), erro: v.string() })
|
|
),
|
|
handler: async (ctx, args) => {
|
|
const usuarioAtual = await getCurrentUserFunction(ctx);
|
|
if (!usuarioAtual) {
|
|
return { sucesso: false as const, erro: "Usuário não autenticado" };
|
|
}
|
|
|
|
const usuario = await ctx.db.get(args.usuarioId);
|
|
if (!usuario) {
|
|
return { sucesso: false as const, erro: "Usuário não encontrado" };
|
|
}
|
|
|
|
// Atualizar usuário como desbloqueado
|
|
await ctx.db.patch(args.usuarioId, {
|
|
bloqueado: false,
|
|
motivoBloqueio: undefined,
|
|
dataBloqueio: undefined,
|
|
tentativasLogin: 0,
|
|
ultimaTentativaLogin: undefined,
|
|
atualizadoEm: Date.now(),
|
|
});
|
|
|
|
// Fechar bloqueios ativos
|
|
const bloqueiosAtivos = await ctx.db
|
|
.query("bloqueiosUsuarios")
|
|
.withIndex("by_usuario", (q) => q.eq("usuarioId", args.usuarioId))
|
|
.filter((q) => q.eq(q.field("ativo"), true))
|
|
.collect();
|
|
|
|
for (const bloqueio of bloqueiosAtivos) {
|
|
await ctx.db.patch(bloqueio._id, {
|
|
ativo: false,
|
|
dataFim: Date.now(),
|
|
desbloqueadoPor: args.desbloqueadoPorId,
|
|
});
|
|
}
|
|
|
|
// Log de atividade
|
|
await registrarAtividade(
|
|
ctx,
|
|
args.desbloqueadoPorId,
|
|
"desbloquear",
|
|
"usuarios",
|
|
JSON.stringify({ usuarioId: args.usuarioId }),
|
|
args.usuarioId
|
|
);
|
|
|
|
return { sucesso: true as const };
|
|
},
|
|
});
|
|
|
|
/**
|
|
* Resetar senha de usuário (apenas TI_MASTER)
|
|
*/
|
|
// export const resetarSenhaUsuario = mutation({
|
|
// args: {
|
|
// usuarioId: v.id("usuarios"),
|
|
// resetadoPorId: v.id("usuarios"),
|
|
// novaSenhaTemporaria: v.optional(v.string()), // Se não fornecer, gera automática
|
|
// },
|
|
// returns: v.union(
|
|
// v.object({ sucesso: v.literal(true), senhaTemporaria: v.string() }),
|
|
// v.object({ sucesso: v.literal(false), erro: v.string() })
|
|
// ),
|
|
// handler: async (ctx, args) => {
|
|
// const usuario = await ctx.db.get(args.usuarioId);
|
|
// if (!usuario) {
|
|
// return { sucesso: false as const, erro: "Usuário não encontrado" };
|
|
// }
|
|
|
|
// // Gerar senha temporária se não foi fornecida
|
|
// const senhaTemporaria = args.novaSenhaTemporaria || gerarSenhaTemporaria();
|
|
// const senhaHash = await hashPassword(senhaTemporaria);
|
|
|
|
// // Atualizar usuário
|
|
// await ctx.db.patch(args.usuarioId, {
|
|
// senhaHash,
|
|
// primeiroAcesso: true, // Força mudança de senha no próximo login
|
|
// tentativasLogin: 0,
|
|
// ultimaTentativaLogin: undefined,
|
|
// atualizadoEm: Date.now(),
|
|
// });
|
|
|
|
// // Log de atividade
|
|
// await registrarAtividade(
|
|
// ctx,
|
|
// args.resetadoPorId,
|
|
// "resetar_senha",
|
|
// "usuarios",
|
|
// JSON.stringify({ usuarioId: args.usuarioId }),
|
|
// args.usuarioId
|
|
// );
|
|
|
|
// return { sucesso: true as const, senhaTemporaria };
|
|
// },
|
|
// });
|
|
|
|
// Helper para gerar senha temporária
|
|
function gerarSenhaTemporaria(): string {
|
|
const chars =
|
|
"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789@#$%";
|
|
let senha = "";
|
|
for (let i = 0; i < 12; i++) {
|
|
senha += chars.charAt(Math.floor(Math.random() * chars.length));
|
|
}
|
|
return senha;
|
|
}
|
|
|
|
/**
|
|
* Editar dados de usuário (apenas TI_MASTER)
|
|
*/
|
|
export const editarUsuario = mutation({
|
|
args: {
|
|
usuarioId: v.id("usuarios"),
|
|
nome: v.optional(v.string()),
|
|
email: v.optional(v.string()),
|
|
roleId: v.optional(v.id("roles")),
|
|
setor: v.optional(v.string()),
|
|
editadoPorId: v.id("usuarios"),
|
|
},
|
|
returns: v.union(
|
|
v.object({ sucesso: v.literal(true) }),
|
|
v.object({ sucesso: v.literal(false), erro: v.string() })
|
|
),
|
|
handler: async (ctx, args) => {
|
|
const usuarioAtual = await getCurrentUserFunction(ctx);
|
|
if (!usuarioAtual) {
|
|
return { sucesso: false as const, erro: "Usuário não autenticado" };
|
|
}
|
|
|
|
const usuario = await ctx.db.get(args.usuarioId);
|
|
if (!usuario) {
|
|
return { sucesso: false as const, erro: "Usuário não encontrado" };
|
|
}
|
|
|
|
// Verificar se email já existe (se estiver mudando)
|
|
if (args.email && args.email !== usuario.email) {
|
|
const emailExistente = await ctx.db
|
|
.query("usuarios")
|
|
.withIndex("by_email", (q) => q.eq("email", args.email!))
|
|
.first();
|
|
|
|
if (emailExistente) {
|
|
return { sucesso: false as const, erro: "E-mail já cadastrado" };
|
|
}
|
|
}
|
|
|
|
// Atualizar campos fornecidos
|
|
const updates: Partial<Doc<"usuarios">> & { atualizadoEm: number } = {
|
|
atualizadoEm: Date.now(),
|
|
};
|
|
|
|
if (args.nome !== undefined) updates.nome = args.nome;
|
|
if (args.email !== undefined) updates.email = args.email;
|
|
if (args.roleId !== undefined) updates.roleId = args.roleId;
|
|
if (args.setor !== undefined) updates.setor = args.setor;
|
|
|
|
await ctx.db.patch(args.usuarioId, updates);
|
|
|
|
// Log de atividade
|
|
await registrarAtividade(
|
|
ctx,
|
|
args.editadoPorId,
|
|
"editar",
|
|
"usuarios",
|
|
JSON.stringify(updates),
|
|
args.usuarioId
|
|
);
|
|
|
|
return { sucesso: true as const };
|
|
},
|
|
});
|
|
|
|
/**
|
|
* Criar/Promover usuário Admin Master (TI_MASTER - nível 0)
|
|
*/
|
|
export const criarAdminMaster = mutation({
|
|
args: {
|
|
nome: v.string(),
|
|
email: v.string(),
|
|
senha: v.optional(v.string()),
|
|
},
|
|
returns: v.union(
|
|
v.object({
|
|
sucesso: v.literal(true),
|
|
usuarioId: v.id("usuarios"),
|
|
senhaTemporaria: v.string(),
|
|
}),
|
|
v.object({ sucesso: v.literal(false), erro: v.string() })
|
|
),
|
|
handler: async (ctx, args) => {
|
|
// Garantir que a role TI_MASTER exista (nível 0)
|
|
let roleTIMaster = await ctx.db
|
|
.query("roles")
|
|
.withIndex("by_nome", (q) => q.eq("nome", "ti_master"))
|
|
.first();
|
|
|
|
if (!roleTIMaster) {
|
|
const roleId = await ctx.db.insert("roles", {
|
|
nome: "ti_master",
|
|
descricao: "TI Master",
|
|
nivel: 0,
|
|
setor: "ti",
|
|
customizado: false,
|
|
editavel: false,
|
|
});
|
|
roleTIMaster = await ctx.db.get(roleId);
|
|
}
|
|
|
|
if (!roleTIMaster) {
|
|
return {
|
|
sucesso: false as const,
|
|
erro: "Falha ao garantir role TI Master",
|
|
};
|
|
}
|
|
|
|
const senhaTemporaria = args.senha || gerarSenhaTemporaria();
|
|
|
|
const authUserId = await createAuthUser(ctx, {
|
|
nome: args.nome,
|
|
email: args.email,
|
|
password: senhaTemporaria,
|
|
});
|
|
|
|
// Verificar se email já existe
|
|
const existentePorEmail = await ctx.db
|
|
.query("usuarios")
|
|
.withIndex("by_email", (q) => q.eq("email", args.email))
|
|
.first();
|
|
if (existentePorEmail) {
|
|
// Promove usuário existente por email
|
|
await ctx.db.patch(existentePorEmail._id, {
|
|
nome: args.nome,
|
|
roleId: roleTIMaster._id,
|
|
ativo: true,
|
|
primeiroAcesso: true,
|
|
atualizadoEm: Date.now(),
|
|
authId: authUserId,
|
|
});
|
|
return {
|
|
sucesso: true as const,
|
|
usuarioId: existentePorEmail._id,
|
|
senhaTemporaria,
|
|
};
|
|
}
|
|
|
|
// Criar novo usuário TI Master
|
|
const usuarioId = await ctx.db.insert("usuarios", {
|
|
authId: authUserId,
|
|
nome: args.nome,
|
|
email: args.email,
|
|
roleId: roleTIMaster._id,
|
|
ativo: true,
|
|
primeiroAcesso: true,
|
|
criadoEm: Date.now(),
|
|
atualizadoEm: Date.now(),
|
|
});
|
|
|
|
return { sucesso: true as const, usuarioId, senhaTemporaria };
|
|
},
|
|
});
|