sgse-app/packages/backend/convex/preferenciasNotificacao.ts

import { v } from "convex/values";
import { mutation, query } from "./_generated/server";
import { Id } from "./_generated/dataModel";

/**
 * Obter preferências de notificação para uma conversa
 */
export const obterPreferenciasConversa = query({
  args: {
    conversaId: v.id("conversas"),
  },
  returns: v.union(
    v.object({
      pushAtivado: v.boolean(),
      emailAtivado: v.boolean(),
      somAtivado: v.boolean(),
      silenciado: v.boolean(),
      apenasMencoes: v.boolean(),
    }),
    v.null()
  ),
  handler: async (ctx, args) => {
    const identity = await ctx.auth.getUserIdentity();
    if (!identity?.email) {
      return null;
    }

    const usuario = await ctx.db
      .query("usuarios")
      .withIndex("by_email", (q) => q.eq("email", identity.email!))
      .first();

    if (!usuario) {
      return null;
    }

    const preferencias = await ctx.db
      .query("preferenciasNotificacaoConversa")
      .withIndex("by_usuario_conversa", (q) =>
        q.eq("usuarioId", usuario._id).eq("conversaId", args.conversaId)
      )
      .first();

    if (!preferencias) {
      // Retornar valores padrão
      return {
        pushAtivado: true,
        emailAtivado: true,
        somAtivado: true,
        silenciado: false,
        apenasMencoes: false,
      };
    }

    return {
      pushAtivado: preferencias.pushAtivado,
      emailAtivado: preferencias.emailAtivado,
      somAtivado: preferencias.somAtivado,
      silenciado: preferencias.silenciado,
      apenasMencoes: preferencias.apenasMencoes,
    };
  },
});

/**
 * Atualizar preferências de notificação para uma conversa
 */
export const atualizarPreferenciasConversa = mutation({
  args: {
    conversaId: v.id("conversas"),
    pushAtivado: v.optional(v.boolean()),
    emailAtivado: v.optional(v.boolean()),
    somAtivado: v.optional(v.boolean()),
    silenciado: v.optional(v.boolean()),
    apenasMencoes: v.optional(v.boolean()),
  },
  returns: v.object({ sucesso: v.boolean() }),
  handler: async (ctx, args) => {
    const identity = await ctx.auth.getUserIdentity();
    if (!identity?.email) {
      return { sucesso: false };
    }

    const usuario = await ctx.db
      .query("usuarios")
      .withIndex("by_email", (q) => q.eq("email", identity.email!))
      .first();

    if (!usuario) {
      return { sucesso: false };
    }

    // Verificar se usuário pertence à conversa
    const conversa = await ctx.db.get(args.conversaId);
    if (!conversa || !conversa.participantes.includes(usuario._id)) {
      return { sucesso: false };
    }

    const preferenciasExistentes = await ctx.db
      .query("preferenciasNotificacaoConversa")
      .withIndex("by_usuario_conversa", (q) =>
        q.eq("usuarioId", usuario._id).eq("conversaId", args.conversaId)
      )
      .first();

    const agora = Date.now();

    if (preferenciasExistentes) {
      // Atualizar preferências existentes
      await ctx.db.patch(preferenciasExistentes._id, {
        pushAtivado: args.pushAtivado ?? preferenciasExistentes.pushAtivado,
        emailAtivado: args.emailAtivado ?? preferenciasExistentes.emailAtivado,
        somAtivado: args.somAtivado ?? preferenciasExistentes.somAtivado,
        silenciado: args.silenciado ?? preferenciasExistentes.silenciado,
        apenasMencoes: args.apenasMencoes ?? preferenciasExistentes.apenasMencoes,
        atualizadoEm: agora,
      });
    } else {
      // Criar novas preferências com valores padrão
      await ctx.db.insert("preferenciasNotificacaoConversa", {
        usuarioId: usuario._id,
        conversaId: args.conversaId,
        pushAtivado: args.pushAtivado ?? true,
        emailAtivado: args.emailAtivado ?? true,
        somAtivado: args.somAtivado ?? true,
        silenciado: args.silenciado ?? false,
        apenasMencoes: args.apenasMencoes ?? false,
        criadoEm: agora,
        atualizadoEm: agora,
      });
    }

    return { sucesso: true };
  },
});