|
|
import type { Database } from 'bun:sqlite';
|
|
|
import { db, ensureUserExists } from '../db';
|
|
|
import { normalizeWhatsAppId, isGroupId } from '../utils/whatsapp';
|
|
|
import { TaskService } from '../tasks/service';
|
|
|
import { GroupSyncService } from './group-sync';
|
|
|
import { ContactsService } from './contacts';
|
|
|
import { ICONS } from '../utils/icons';
|
|
|
import { padTaskId, codeId, formatDDMM, bold, italic } from '../utils/formatting';
|
|
|
|
|
|
type CommandContext = {
|
|
|
sender: string; // normalized user id (digits only), but accept raw too
|
|
|
groupId: string; // full JID (e.g., xxx@g.us)
|
|
|
message: string; // raw message text
|
|
|
mentions: string[]; // array of raw JIDs mentioned
|
|
|
};
|
|
|
|
|
|
export type CommandResponse = {
|
|
|
recipient: string;
|
|
|
message: string;
|
|
|
mentions?: string[]; // full JIDs to mention in the outgoing message
|
|
|
};
|
|
|
|
|
|
export class CommandService {
|
|
|
static dbInstance: Database = db;
|
|
|
|
|
|
private static parseNueva(message: string, mentionsNormalized: string[]): {
|
|
|
action: string;
|
|
|
description: string;
|
|
|
dueDate: string | null;
|
|
|
} {
|
|
|
const parts = (message || '').trim().split(/\s+/);
|
|
|
const action = (parts[1] || '').toLowerCase();
|
|
|
|
|
|
// Zona horaria configurable (por defecto Europe/Madrid)
|
|
|
const TZ = process.env.TZ && process.env.TZ.trim() ? process.env.TZ : 'Europe/Madrid';
|
|
|
|
|
|
// Utilidades locales para operar con fechas en la TZ elegida sin depender del huso del host
|
|
|
const ymdFromDateInTZ = (d: Date): string => {
|
|
|
const fmt = new Intl.DateTimeFormat('en-GB', {
|
|
|
timeZone: TZ,
|
|
|
year: 'numeric',
|
|
|
month: '2-digit',
|
|
|
day: '2-digit',
|
|
|
}).formatToParts(d);
|
|
|
const get = (t: string) => fmt.find(p => p.type === t)?.value || '';
|
|
|
return `${get('year')}-${get('month')}-${get('day')}`;
|
|
|
};
|
|
|
|
|
|
const addDaysToYMD = (ymd: string, days: number): string => {
|
|
|
const [Y, M, D] = ymd.split('-').map(n => parseInt(n, 10));
|
|
|
const base = new Date(Date.UTC(Y, (M || 1) - 1, D || 1));
|
|
|
base.setUTCDate(base.getUTCDate() + days);
|
|
|
return ymdFromDateInTZ(base);
|
|
|
};
|
|
|
|
|
|
const todayYMD = ymdFromDateInTZ(new Date());
|
|
|
|
|
|
type DateCandidate = { index: number; ymd: string };
|
|
|
const dateCandidates: DateCandidate[] = [];
|
|
|
const dateTokenIndexes = new Set<number>();
|
|
|
|
|
|
for (let i = 2; i < parts.length; i++) {
|
|
|
// Normalizar token: minúsculas y sin puntuación adyacente simple
|
|
|
const raw = parts[i];
|
|
|
const low = raw.toLowerCase().replace(/^[([{¿¡"']+/, '').replace(/[.,;:!?)\]}¿¡"'']+$/, '');
|
|
|
|
|
|
// Fecha explícita YYYY-MM-DD
|
|
|
if (/^\d{4}-\d{2}-\d{2}$/.test(low)) {
|
|
|
// Validar rango básico y filtrar pasado según hoy en TZ
|
|
|
if (low >= todayYMD) {
|
|
|
dateCandidates.push({ index: i, ymd: low });
|
|
|
dateTokenIndexes.add(i);
|
|
|
}
|
|
|
continue;
|
|
|
}
|
|
|
|
|
|
// Tokens naturales "hoy"/"mañana" (con o sin acento)
|
|
|
if (low === 'hoy') {
|
|
|
dateCandidates.push({ index: i, ymd: todayYMD });
|
|
|
dateTokenIndexes.add(i);
|
|
|
continue;
|
|
|
}
|
|
|
if (low === 'mañana' || low === 'manana') {
|
|
|
dateCandidates.push({ index: i, ymd: addDaysToYMD(todayYMD, 1) });
|
|
|
dateTokenIndexes.add(i);
|
|
|
continue;
|
|
|
}
|
|
|
}
|
|
|
|
|
|
const dueDate = dateCandidates.length > 0
|
|
|
? dateCandidates[dateCandidates.length - 1].ymd
|
|
|
: null;
|
|
|
|
|
|
const isMentionToken = (token: string) => token.startsWith('@');
|
|
|
|
|
|
const descriptionTokens: string[] = [];
|
|
|
for (let i = 2; i < parts.length; i++) {
|
|
|
if (dateTokenIndexes.has(i)) continue;
|
|
|
const token = parts[i];
|
|
|
if (isMentionToken(token)) continue;
|
|
|
descriptionTokens.push(token);
|
|
|
}
|
|
|
|
|
|
const description = descriptionTokens.join(' ').trim();
|
|
|
|
|
|
return { action, description, dueDate };
|
|
|
}
|
|
|
|
|
|
private static async processTareaCommand(
|
|
|
context: CommandContext
|
|
|
): Promise<CommandResponse[]> {
|
|
|
const trimmed = (context.message || '').trim();
|
|
|
const tokens = trimmed.split(/\s+/);
|
|
|
const rawAction = (tokens[1] || '').toLowerCase();
|
|
|
const ACTION_ALIASES: Record<string, string> = {
|
|
|
'n': 'nueva',
|
|
|
'nueva': 'nueva',
|
|
|
'crear': 'nueva',
|
|
|
'+': 'nueva',
|
|
|
'ver': 'ver',
|
|
|
'mostrar': 'ver',
|
|
|
'listar': 'ver',
|
|
|
'ls': 'ver',
|
|
|
'x': 'completar',
|
|
|
'hecho': 'completar',
|
|
|
'completar': 'completar',
|
|
|
'done': 'completar',
|
|
|
'tomar': 'tomar',
|
|
|
'claim': 'tomar',
|
|
|
'asumir': 'tomar',
|
|
|
'asumo': 'tomar',
|
|
|
'soltar': 'soltar',
|
|
|
'unassign': 'soltar',
|
|
|
'dejar': 'soltar',
|
|
|
'liberar': 'soltar',
|
|
|
'renunciar': 'soltar',
|
|
|
'ayuda': 'ayuda',
|
|
|
'help': 'ayuda',
|
|
|
'?': 'ayuda',
|
|
|
'config': 'configurar',
|
|
|
'configurar': 'configurar'
|
|
|
};
|
|
|
const action = ACTION_ALIASES[rawAction] || rawAction;
|
|
|
|
|
|
// Usar formatDDMM desde utils/formatting
|
|
|
|
|
|
// TZ y "hoy" en TZ para marcar vencidas en listados
|
|
|
const TZ = process.env.TZ && process.env.TZ.trim() ? process.env.TZ : 'Europe/Madrid';
|
|
|
const ymdInTZ = (d: Date): string => {
|
|
|
const parts = new Intl.DateTimeFormat('en-GB', {
|
|
|
timeZone: TZ,
|
|
|
year: 'numeric',
|
|
|
month: '2-digit',
|
|
|
day: '2-digit',
|
|
|
}).formatToParts(d);
|
|
|
const get = (t: string) => parts.find(p => p.type === t)?.value || '';
|
|
|
return `${get('year')}-${get('month')}-${get('day')}`;
|
|
|
};
|
|
|
const todayYMD = ymdInTZ(new Date());
|
|
|
|
|
|
if (!action || action === 'ayuda') {
|
|
|
const isAdvanced = (tokens[2] || '').toLowerCase() === 'avanzada';
|
|
|
if (isAdvanced) {
|
|
|
const adv = [
|
|
|
'Ayuda avanzada:',
|
|
|
'- Comandos y alias:',
|
|
|
' · Crear: n, nueva, crear, +',
|
|
|
' · Ver: ver, mostrar, listar, ls (scopes: grupo | mis | todos | sin)',
|
|
|
' · Completar: x, hecho, completar, done',
|
|
|
' · Tomar: tomar, claim',
|
|
|
' · Soltar: soltar, unassign',
|
|
|
'- Preferencias:',
|
|
|
' · /t configurar daily|weekly|off (hora por defecto 08:30; semanal: lunes 08:30)',
|
|
|
'- Notas:',
|
|
|
' · En grupos, el bot responde por DM al autor (no publica en el grupo).',
|
|
|
' · Si creas en grupo y no mencionas a nadie → “sin responsable”; en DM → se asigna al creador.',
|
|
|
' · Fechas dd/MM con ⚠️ si está vencida.',
|
|
|
' · Mostramos los IDs con 4 dígitos, pero puedes escribirlos sin ceros (p. ej., 26).',
|
|
|
].join('\n');
|
|
|
return [{
|
|
|
recipient: context.sender,
|
|
|
message: adv
|
|
|
}];
|
|
|
}
|
|
|
const help = [
|
|
|
'Guía rápida:',
|
|
|
'- Crear: /t n Descripción mañana @Ana',
|
|
|
'- Ver grupo: /t ver grupo',
|
|
|
'- Ver mis: /t ver mis',
|
|
|
'- Ver todos: /t ver todos',
|
|
|
'- Completar: /t x 123',
|
|
|
'- Configurar recordatorios: /t configurar daily|weekly|off'
|
|
|
].join('\n');
|
|
|
return [{
|
|
|
recipient: context.sender,
|
|
|
message: help
|
|
|
}];
|
|
|
}
|
|
|
|
|
|
// Listar pendientes
|
|
|
if (action === 'ver') {
|
|
|
const scopeRaw = (tokens[2] || '').toLowerCase();
|
|
|
const SCOPE_ALIASES: Record<string, 'grupo' | 'mis' | 'todos' | 'sin'> = {
|
|
|
'todo': 'todos',
|
|
|
'todos': 'todos',
|
|
|
'todas': 'todos',
|
|
|
'mis': 'mis',
|
|
|
'mias': 'mis',
|
|
|
'mías': 'mis',
|
|
|
'yo': 'mis',
|
|
|
};
|
|
|
const scope = scopeRaw ? (SCOPE_ALIASES[scopeRaw] || scopeRaw) : (isGroupId(context.groupId) ? 'grupo' : 'mis');
|
|
|
const LIMIT = 10;
|
|
|
|
|
|
// Ver sin dueño del grupo actual
|
|
|
if (scope === 'sin') {
|
|
|
if (!isGroupId(context.groupId)) {
|
|
|
return [{
|
|
|
recipient: context.sender,
|
|
|
message: 'Este comando se usa en grupos. Prueba: /t ver mis'
|
|
|
}];
|
|
|
}
|
|
|
if (!GroupSyncService.isGroupActive(context.groupId)) {
|
|
|
return [{
|
|
|
recipient: context.sender,
|
|
|
message: '⚠️ Este grupo no está activo.'
|
|
|
}];
|
|
|
}
|
|
|
const items = TaskService.listGroupUnassigned(context.groupId, LIMIT);
|
|
|
const groupName = GroupSyncService.activeGroupsCache.get(context.groupId) || context.groupId;
|
|
|
|
|
|
if (items.length === 0) {
|
|
|
return [{
|
|
|
recipient: context.sender,
|
|
|
message: `No hay tareas sin responsable en ${groupName}.`
|
|
|
}];
|
|
|
}
|
|
|
|
|
|
const rendered = items.map((t) => {
|
|
|
const isOverdue = t.due_date ? t.due_date < todayYMD : false;
|
|
|
const datePart = t.due_date ? ` — ${isOverdue ? `${ICONS.warn} ` : ''}${ICONS.date} ${formatDDMM(t.due_date)}` : '';
|
|
|
return `- ${codeId(t.id)} _${t.description || '(sin descripción)'}_${datePart} — ${ICONS.unassigned} sin responsable`;
|
|
|
});
|
|
|
|
|
|
const total = TaskService.countGroupUnassigned(context.groupId);
|
|
|
if (total > items.length) {
|
|
|
rendered.push(`… y ${total - items.length} más`);
|
|
|
}
|
|
|
|
|
|
return [{
|
|
|
recipient: context.sender,
|
|
|
message: [`${groupName} — Sin responsable`, ...rendered].join('\n')
|
|
|
}];
|
|
|
}
|
|
|
|
|
|
// Ver todos: "tus tareas" + "sin responsable" de grupos donde eres miembro activo (snapshot fresca)
|
|
|
if (scope === 'todos') {
|
|
|
const sections: string[] = [];
|
|
|
|
|
|
// Encabezado fijo para la sección de tareas del usuario
|
|
|
sections.push(bold('Tus tareas'));
|
|
|
|
|
|
// Tus tareas (mis)
|
|
|
const myItems = TaskService.listUserPending(context.sender, LIMIT);
|
|
|
if (myItems.length > 0) {
|
|
|
// Agrupar por grupo como en "ver mis"
|
|
|
const byGroup = new Map<string, typeof myItems>();
|
|
|
for (const t of myItems) {
|
|
|
const key = t.group_id || '(sin grupo)';
|
|
|
const arr = byGroup.get(key) || [];
|
|
|
arr.push(t);
|
|
|
byGroup.set(key, arr);
|
|
|
}
|
|
|
|
|
|
for (const [groupId, arr] of byGroup.entries()) {
|
|
|
const groupName =
|
|
|
(groupId && GroupSyncService.activeGroupsCache.get(groupId)) ||
|
|
|
(groupId && groupId !== '(sin grupo)' ? groupId : 'Sin grupo');
|
|
|
|
|
|
sections.push(groupName);
|
|
|
const rendered = await Promise.all(arr.map(async (t) => {
|
|
|
const names = await Promise.all(
|
|
|
(t.assignees || []).map(async (uid) => (await ContactsService.getDisplayName(uid)) || uid)
|
|
|
);
|
|
|
const owner =
|
|
|
(t.assignees?.length || 0) === 0
|
|
|
? `${ICONS.unassigned} sin responsable`
|
|
|
: `${t.assignees!.length > 1 ? '👥' : '👤'} ${names.join(', ')}`;
|
|
|
const isOverdue = t.due_date ? t.due_date < todayYMD : false;
|
|
|
const datePart = t.due_date ? ` — ${isOverdue ? `${ICONS.warn} ` : ''}${ICONS.date} ${formatDDMM(t.due_date)}` : '';
|
|
|
return `- ${codeId(t.id)} _${t.description || '(sin descripción)'}_${datePart} — ${owner}`;
|
|
|
}));
|
|
|
sections.push(...rendered);
|
|
|
}
|
|
|
|
|
|
const totalMy = TaskService.countUserPending(context.sender);
|
|
|
if (totalMy > myItems.length) {
|
|
|
sections.push(`… y ${totalMy - myItems.length} más`);
|
|
|
}
|
|
|
} else {
|
|
|
sections.push('No tienes tareas pendientes.');
|
|
|
}
|
|
|
|
|
|
// En contexto de grupo: mantener compatibilidad mostrando solo "sin responsable" del grupo actual
|
|
|
if (isGroupId(context.groupId)) {
|
|
|
if (!GroupSyncService.isGroupActive(context.groupId)) {
|
|
|
sections.push('⚠️ Este grupo no está activo.');
|
|
|
} else {
|
|
|
const groupName = GroupSyncService.activeGroupsCache.get(context.groupId) || context.groupId;
|
|
|
const unassigned = TaskService.listGroupUnassigned(context.groupId, LIMIT);
|
|
|
if (unassigned.length > 0) {
|
|
|
sections.push(`${groupName} — Sin responsable`);
|
|
|
const renderedUnassigned = unassigned.map((t) => {
|
|
|
const isOverdue = t.due_date ? t.due_date < todayYMD : false;
|
|
|
const datePart = t.due_date ? ` — ${isOverdue ? `${ICONS.warn} ` : ''}${ICONS.date} ${formatDDMM(t.due_date)}` : '';
|
|
|
return `- ${codeId(t.id)} _${t.description || '(sin descripción)'}_${datePart} — ${ICONS.unassigned} sin responsable`;
|
|
|
});
|
|
|
sections.push(...renderedUnassigned);
|
|
|
|
|
|
const totalUnassigned = TaskService.countGroupUnassigned(context.groupId);
|
|
|
if (totalUnassigned > unassigned.length) {
|
|
|
sections.push(`… y ${totalUnassigned - unassigned.length} más`);
|
|
|
}
|
|
|
} else {
|
|
|
sections.push(`${groupName} — Sin responsable\n(no hay tareas sin responsable)`);
|
|
|
}
|
|
|
}
|
|
|
} else {
|
|
|
// En DM: usar membresía real (snapshot fresca) para incluir "sin responsable" por grupo
|
|
|
const memberGroups = GroupSyncService.getFreshMemberGroupsForUser(context.sender);
|
|
|
if (memberGroups.length > 0) {
|
|
|
const perGroup = TaskService.listUnassignedByGroups(memberGroups, LIMIT);
|
|
|
for (const gid of perGroup.keys()) {
|
|
|
const unassigned = perGroup.get(gid)!;
|
|
|
const groupName =
|
|
|
(gid && GroupSyncService.activeGroupsCache.get(gid)) ||
|
|
|
gid;
|
|
|
|
|
|
if (unassigned.length > 0) {
|
|
|
sections.push(`${groupName} — Sin responsable`);
|
|
|
const renderedUnassigned = unassigned.map((t) => {
|
|
|
const isOverdue = t.due_date ? t.due_date < todayYMD : false;
|
|
|
const datePart = t.due_date ? ` — ${isOverdue ? `${ICONS.warn} ` : ''}${ICONS.date} ${formatDDMM(t.due_date)}` : '';
|
|
|
return `- ${codeId(t.id)} _${t.description || '(sin descripción)'}_${datePart} — ${ICONS.unassigned} sin responsable`;
|
|
|
});
|
|
|
sections.push(...renderedUnassigned);
|
|
|
|
|
|
const totalUnassigned = TaskService.countGroupUnassigned(gid);
|
|
|
if (totalUnassigned > unassigned.length) {
|
|
|
sections.push(`… y ${totalUnassigned - unassigned.length} más`);
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
} else {
|
|
|
// Si no hay snapshot fresca de membresía, mantenemos una nota instructiva mínima
|
|
|
sections.push('ℹ️ Para ver tareas sin responsable de un grupo, usa “/t ver sin” desde ese grupo.');
|
|
|
}
|
|
|
}
|
|
|
|
|
|
return [{
|
|
|
recipient: context.sender,
|
|
|
message: sections.join('\n')
|
|
|
}];
|
|
|
}
|
|
|
|
|
|
// Ver grupo
|
|
|
if (scope === 'grupo') {
|
|
|
if (!isGroupId(context.groupId)) {
|
|
|
return [{
|
|
|
recipient: context.sender,
|
|
|
message: 'Este comando se usa en grupos. Prueba: /t ver mis'
|
|
|
}];
|
|
|
}
|
|
|
if (!GroupSyncService.isGroupActive(context.groupId)) {
|
|
|
return [{
|
|
|
recipient: context.sender,
|
|
|
message: '⚠️ Este grupo no está activo.'
|
|
|
}];
|
|
|
}
|
|
|
// Enforcement opcional basado en membresía si la snapshot es fresca
|
|
|
const enforce = String(process.env.GROUP_MEMBERS_ENFORCE || '').toLowerCase() === 'true';
|
|
|
const fresh = GroupSyncService.isSnapshotFresh(context.groupId);
|
|
|
if (enforce && fresh && !GroupSyncService.isUserActiveInGroup(context.sender, context.groupId)) {
|
|
|
return [{
|
|
|
recipient: context.sender,
|
|
|
message: 'No puedes ver las tareas de este grupo porque no apareces como miembro activo. Pide acceso a un admin si crees que es un error.'
|
|
|
}];
|
|
|
}
|
|
|
|
|
|
const items = TaskService.listGroupPending(context.groupId, LIMIT);
|
|
|
const groupName = GroupSyncService.activeGroupsCache.get(context.groupId) || context.groupId;
|
|
|
|
|
|
if (items.length === 0) {
|
|
|
return [{
|
|
|
recipient: context.sender,
|
|
|
message: `No hay pendientes en ${groupName}.`
|
|
|
}];
|
|
|
}
|
|
|
|
|
|
const rendered = await Promise.all(items.map(async (t) => {
|
|
|
const names = await Promise.all(
|
|
|
(t.assignees || []).map(async (uid) => (await ContactsService.getDisplayName(uid)) || uid)
|
|
|
);
|
|
|
const owner =
|
|
|
(t.assignees?.length || 0) === 0
|
|
|
? `${ICONS.unassigned} sin responsable`
|
|
|
: `${t.assignees!.length > 1 ? '👥' : '👤'} ${names.join(', ')}`;
|
|
|
const isOverdue = t.due_date ? t.due_date < todayYMD : false;
|
|
|
const datePart = t.due_date ? ` — ${isOverdue ? `${ICONS.warn} ` : ''}${ICONS.date} ${formatDDMM(t.due_date)}` : '';
|
|
|
return `- ${codeId(t.id)} _${t.description || '(sin descripción)'}_${datePart} — ${owner}`;
|
|
|
}));
|
|
|
|
|
|
const total = TaskService.countGroupPending(context.groupId);
|
|
|
if (total > items.length) {
|
|
|
rendered.push(`… y ${total - items.length} más`);
|
|
|
}
|
|
|
|
|
|
return [{
|
|
|
recipient: context.sender,
|
|
|
message: [groupName, ...rendered].join('\n')
|
|
|
}];
|
|
|
}
|
|
|
|
|
|
// Ver mis
|
|
|
const items = TaskService.listUserPending(context.sender, LIMIT);
|
|
|
if (items.length === 0) {
|
|
|
return [{
|
|
|
recipient: context.sender,
|
|
|
message: 'No tienes tareas pendientes.'
|
|
|
}];
|
|
|
}
|
|
|
|
|
|
const total = TaskService.countUserPending(context.sender);
|
|
|
|
|
|
// Agrupar por grupo
|
|
|
const byGroup = new Map<string, typeof items>();
|
|
|
for (const t of items) {
|
|
|
const key = t.group_id || '(sin grupo)';
|
|
|
const arr = byGroup.get(key) || [];
|
|
|
arr.push(t);
|
|
|
byGroup.set(key, arr);
|
|
|
}
|
|
|
|
|
|
const sections: string[] = [];
|
|
|
for (const [groupId, arr] of byGroup.entries()) {
|
|
|
const groupName =
|
|
|
(groupId && GroupSyncService.activeGroupsCache.get(groupId)) ||
|
|
|
(groupId && groupId !== '(sin grupo)' ? groupId : 'Sin grupo');
|
|
|
|
|
|
sections.push(groupName);
|
|
|
const rendered = await Promise.all(arr.map(async (t) => {
|
|
|
const names = await Promise.all(
|
|
|
(t.assignees || []).map(async (uid) => (await ContactsService.getDisplayName(uid)) || uid)
|
|
|
);
|
|
|
const owner =
|
|
|
(t.assignees?.length || 0) === 0
|
|
|
? `${ICONS.unassigned} sin responsable`
|
|
|
: `${t.assignees!.length > 1 ? '👥' : '👤'} ${names.join(', ')}`;
|
|
|
const isOverdue = t.due_date ? t.due_date < todayYMD : false;
|
|
|
const datePart = t.due_date ? ` — ${isOverdue ? `${ICONS.warn} ` : ''}${ICONS.date} ${formatDDMM(t.due_date)}` : '';
|
|
|
return `- ${codeId(t.id)} _${t.description || '(sin descripción)'}_${datePart} — ${owner}`;
|
|
|
}));
|
|
|
sections.push(...rendered);
|
|
|
}
|
|
|
|
|
|
if (total > items.length) {
|
|
|
sections.push(`… y ${total - items.length} más`);
|
|
|
}
|
|
|
|
|
|
return [{
|
|
|
recipient: context.sender,
|
|
|
message: sections.join('\n')
|
|
|
}];
|
|
|
}
|
|
|
|
|
|
// Completar tarea (con validación opcional de membresía)
|
|
|
if (action === 'completar') {
|
|
|
const idToken = tokens[2];
|
|
|
const id = idToken ? parseInt(idToken, 10) : NaN;
|
|
|
if (!id || Number.isNaN(id)) {
|
|
|
return [{
|
|
|
recipient: context.sender,
|
|
|
message: 'ℹ️ Uso: /t x 26'
|
|
|
}];
|
|
|
}
|
|
|
|
|
|
const task = TaskService.getTaskById(id);
|
|
|
if (!task) {
|
|
|
return [{
|
|
|
recipient: context.sender,
|
|
|
message: `⚠️ Tarea ${codeId(id)} no encontrada.`
|
|
|
}];
|
|
|
}
|
|
|
const enforce = String(process.env.GROUP_MEMBERS_ENFORCE || '').toLowerCase() === 'true';
|
|
|
if (task.group_id && GroupSyncService.isSnapshotFresh(task.group_id) && enforce && !GroupSyncService.isUserActiveInGroup(context.sender, task.group_id)) {
|
|
|
return [{
|
|
|
recipient: context.sender,
|
|
|
message: 'No puedes completar esta tarea porque no apareces como miembro activo del grupo.'
|
|
|
}];
|
|
|
}
|
|
|
|
|
|
const res = TaskService.completeTask(id, context.sender);
|
|
|
const who = (await ContactsService.getDisplayName(context.sender)) || context.sender;
|
|
|
if (res.status === 'not_found') {
|
|
|
return [{
|
|
|
recipient: context.sender,
|
|
|
message: `⚠️ Tarea ${codeId(id)} no encontrada.`
|
|
|
}];
|
|
|
}
|
|
|
if (res.status === 'already') {
|
|
|
const due = res.task?.due_date ? ` — ${ICONS.date} ${formatDDMM(res.task?.due_date)}` : '';
|
|
|
return [{
|
|
|
recipient: context.sender,
|
|
|
message: `ℹ️ ${codeId(id)} ya estaba completada — _${res.task?.description || '(sin descripción)'}_${due}`
|
|
|
}];
|
|
|
}
|
|
|
|
|
|
const due = res.task?.due_date ? ` — ${ICONS.date} ${formatDDMM(res.task?.due_date)}` : '';
|
|
|
return [{
|
|
|
recipient: context.sender,
|
|
|
message: `${ICONS.complete} ${codeId(id)} completada — _${res.task?.description || '(sin descripción)'}_${due}`
|
|
|
}];
|
|
|
}
|
|
|
|
|
|
// Tomar tarea (con validación opcional de membresía)
|
|
|
if (action === 'tomar') {
|
|
|
const idToken = tokens[2];
|
|
|
const id = idToken ? parseInt(idToken, 10) : NaN;
|
|
|
if (!id || Number.isNaN(id)) {
|
|
|
return [{
|
|
|
recipient: context.sender,
|
|
|
message: 'ℹ️ Uso: /t tomar 26'
|
|
|
}];
|
|
|
}
|
|
|
|
|
|
const task = TaskService.getTaskById(id);
|
|
|
if (!task) {
|
|
|
return [{
|
|
|
recipient: context.sender,
|
|
|
message: `⚠️ Tarea ${codeId(id)} no encontrada.`
|
|
|
}];
|
|
|
}
|
|
|
const enforce = String(process.env.GROUP_MEMBERS_ENFORCE || '').toLowerCase() === 'true';
|
|
|
if (task.group_id && GroupSyncService.isSnapshotFresh(task.group_id) && enforce && !GroupSyncService.isUserActiveInGroup(context.sender, task.group_id)) {
|
|
|
return [{
|
|
|
recipient: context.sender,
|
|
|
message: 'No puedes tomar esta tarea: no apareces como miembro activo del grupo. Pide acceso a un admin si crees que es un error.'
|
|
|
}];
|
|
|
}
|
|
|
|
|
|
const res = TaskService.claimTask(id, context.sender);
|
|
|
const due = res.task?.due_date ? ` — ${ICONS.date} ${formatDDMM(res.task?.due_date)}` : '';
|
|
|
|
|
|
if (res.status === 'not_found') {
|
|
|
return [{
|
|
|
recipient: context.sender,
|
|
|
message: `⚠️ Tarea ${codeId(id)} no encontrada.`
|
|
|
}];
|
|
|
}
|
|
|
if (res.status === 'completed') {
|
|
|
return [{
|
|
|
recipient: context.sender,
|
|
|
message: `ℹ️ ${codeId(id)} ya estaba completada — ${res.task?.description || '(sin descripción)'}${due}`
|
|
|
}];
|
|
|
}
|
|
|
if (res.status === 'already') {
|
|
|
return [{
|
|
|
recipient: context.sender,
|
|
|
message: `ℹ️ ${codeId(id)} ya la tenías — ${res.task?.description || '(sin descripción)'}${due}`
|
|
|
}];
|
|
|
}
|
|
|
|
|
|
const lines = [
|
|
|
`${ICONS.take} Has tomado ${codeId(id)}`,
|
|
|
`${res.task?.description || '(sin descripción)'}`,
|
|
|
res.task?.due_date ? `${ICONS.date} ${formatDDMM(res.task?.due_date)}` : ''
|
|
|
].filter(Boolean);
|
|
|
return [{
|
|
|
recipient: context.sender,
|
|
|
message: lines.join('\n')
|
|
|
}];
|
|
|
}
|
|
|
|
|
|
// Soltar tarea (con validación opcional de membresía)
|
|
|
if (action === 'soltar') {
|
|
|
const idToken = tokens[2];
|
|
|
const id = idToken ? parseInt(idToken, 10) : NaN;
|
|
|
if (!id || Number.isNaN(id)) {
|
|
|
return [{
|
|
|
recipient: context.sender,
|
|
|
message: 'ℹ️ Uso: /t soltar 26'
|
|
|
}];
|
|
|
}
|
|
|
|
|
|
const task = TaskService.getTaskById(id);
|
|
|
if (!task) {
|
|
|
return [{
|
|
|
recipient: context.sender,
|
|
|
message: `⚠️ Tarea ${codeId(id)} no encontrada.`
|
|
|
}];
|
|
|
}
|
|
|
const enforce = String(process.env.GROUP_MEMBERS_ENFORCE || '').toLowerCase() === 'true';
|
|
|
if (task.group_id && GroupSyncService.isSnapshotFresh(task.group_id) && enforce && !GroupSyncService.isUserActiveInGroup(context.sender, task.group_id)) {
|
|
|
return [{
|
|
|
recipient: context.sender,
|
|
|
message: 'No puedes soltar esta tarea porque no apareces como miembro activo del grupo.'
|
|
|
}];
|
|
|
}
|
|
|
|
|
|
const res = TaskService.unassignTask(id, context.sender);
|
|
|
const due = res.task?.due_date ? ` — ${ICONS.date} ${formatDDMM(res.task?.due_date)}` : '';
|
|
|
|
|
|
if (res.status === 'not_found') {
|
|
|
return [{
|
|
|
recipient: context.sender,
|
|
|
message: `⚠️ Tarea ${codeId(id)} no encontrada.`
|
|
|
}];
|
|
|
}
|
|
|
if (res.status === 'completed') {
|
|
|
return [{
|
|
|
recipient: context.sender,
|
|
|
message: `ℹ️ ${codeId(id)} ya estaba completada — ${res.task?.description || '(sin descripción)'}${due}`
|
|
|
}];
|
|
|
}
|
|
|
if (res.status === 'not_assigned') {
|
|
|
return [{
|
|
|
recipient: context.sender,
|
|
|
message: `ℹ️ ${codeId(id)} no la tenías asignada — ${res.task?.description || '(sin descripción)'}${due}`
|
|
|
}];
|
|
|
}
|
|
|
|
|
|
if (res.now_unassigned) {
|
|
|
const lines = [
|
|
|
`${ICONS.unassigned} ${codeId(id)}`,
|
|
|
`${res.task?.description || '(sin descripción)'}`,
|
|
|
res.task?.due_date ? `${ICONS.date} ${formatDDMM(res.task?.due_date)}` : '',
|
|
|
italic('queda sin responsable.')
|
|
|
].filter(Boolean);
|
|
|
return [{
|
|
|
recipient: context.sender,
|
|
|
message: lines.join('\n')
|
|
|
}];
|
|
|
}
|
|
|
|
|
|
const lines = [
|
|
|
`${ICONS.unassign} ${codeId(id)}`,
|
|
|
`${res.task?.description || '(sin descripción)'}`,
|
|
|
res.task?.due_date ? `${ICONS.date} ${formatDDMM(res.task?.due_date)}` : ''
|
|
|
].filter(Boolean);
|
|
|
return [{
|
|
|
recipient: context.sender,
|
|
|
message: lines.join('\n')
|
|
|
}];
|
|
|
}
|
|
|
|
|
|
if (action === 'configurar') {
|
|
|
const optRaw = (tokens[2] || '').toLowerCase();
|
|
|
const map: Record<string, 'daily' | 'weekly' | 'off'> = {
|
|
|
'daily': 'daily',
|
|
|
'diario': 'daily',
|
|
|
'diaria': 'daily',
|
|
|
'semanal': 'weekly',
|
|
|
'weekly': 'weekly',
|
|
|
'off': 'off',
|
|
|
'apagar': 'off',
|
|
|
'ninguno': 'off'
|
|
|
};
|
|
|
const freq = map[optRaw];
|
|
|
if (!freq) {
|
|
|
return [{
|
|
|
recipient: context.sender,
|
|
|
message: 'Uso: /t configurar daily|weekly|off'
|
|
|
}];
|
|
|
}
|
|
|
const ensured = ensureUserExists(context.sender, this.dbInstance);
|
|
|
if (!ensured) {
|
|
|
throw new Error('No se pudo asegurar el usuario');
|
|
|
}
|
|
|
this.dbInstance.prepare(`
|
|
|
INSERT INTO user_preferences (user_id, reminder_freq, reminder_time, last_reminded_on, updated_at)
|
|
|
VALUES (?, ?, COALESCE((SELECT reminder_time FROM user_preferences WHERE user_id = ?), '08:30'), NULL, strftime('%Y-%m-%d %H:%M:%f', 'now'))
|
|
|
ON CONFLICT(user_id) DO UPDATE SET
|
|
|
reminder_freq = excluded.reminder_freq,
|
|
|
updated_at = excluded.updated_at
|
|
|
`).run(ensured, freq, ensured);
|
|
|
const label = freq === 'daily' ? 'diario' : freq === 'weekly' ? 'semanal (lunes 08:30)' : 'apagado';
|
|
|
return [{
|
|
|
recipient: context.sender,
|
|
|
message: `✅ Recordatorios: ${label}`
|
|
|
}];
|
|
|
}
|
|
|
|
|
|
if (action !== 'nueva') {
|
|
|
return [{
|
|
|
recipient: context.sender,
|
|
|
message: `Acción ${rawAction || '(vacía)'} no implementada aún`
|
|
|
}];
|
|
|
}
|
|
|
|
|
|
// Parseo específico de "nueva"
|
|
|
// Normalizar menciones del contexto para parseo y asignaciones
|
|
|
const mentionsNormalizedFromContext = Array.from(new Set(
|
|
|
(context.mentions || [])
|
|
|
.map(j => normalizeWhatsAppId(j))
|
|
|
.filter((id): id is string => !!id)
|
|
|
));
|
|
|
// Detectar también tokens de texto que empiezan por '@' como posibles asignados
|
|
|
const atTokenCandidates = tokens.slice(2)
|
|
|
.filter(t => t.startsWith('@'))
|
|
|
.map(t => t.replace(/^@+/, ''));
|
|
|
const normalizedFromAtTokens = Array.from(new Set(
|
|
|
atTokenCandidates
|
|
|
.map(v => normalizeWhatsAppId(v))
|
|
|
.filter((id): id is string => !!id)
|
|
|
));
|
|
|
const combinedAssigneeCandidates = Array.from(new Set([
|
|
|
...mentionsNormalizedFromContext,
|
|
|
...normalizedFromAtTokens
|
|
|
]));
|
|
|
|
|
|
const { description, dueDate } = this.parseNueva(trimmed, mentionsNormalizedFromContext);
|
|
|
|
|
|
// Asegurar creador
|
|
|
const createdBy = ensureUserExists(context.sender, this.dbInstance);
|
|
|
if (!createdBy) {
|
|
|
throw new Error('No se pudo asegurar el usuario creador');
|
|
|
}
|
|
|
|
|
|
// Normalizar menciones y excluir duplicados y el número del bot
|
|
|
const botNumber = process.env.CHATBOT_PHONE_NUMBER || '';
|
|
|
const assigneesNormalized = Array.from(new Set(
|
|
|
combinedAssigneeCandidates
|
|
|
.filter(id => !botNumber || id !== botNumber)
|
|
|
));
|
|
|
|
|
|
// Asegurar usuarios asignados
|
|
|
const ensuredAssignees = assigneesNormalized
|
|
|
.map(id => ensureUserExists(id, this.dbInstance))
|
|
|
.filter((id): id is string => !!id);
|
|
|
|
|
|
// Asignación por defecto según contexto:
|
|
|
// - En grupos: si no hay menciones → sin dueño (ningún asignado)
|
|
|
// - En DM: si no hay menciones → asignada al creador
|
|
|
let assignmentUserIds: string[] = [];
|
|
|
if (ensuredAssignees.length > 0) {
|
|
|
assignmentUserIds = ensuredAssignees;
|
|
|
} else {
|
|
|
assignmentUserIds = (context.groupId && isGroupId(context.groupId)) ? [] : [createdBy];
|
|
|
}
|
|
|
|
|
|
// Definir group_id solo si el grupo está activo
|
|
|
const groupIdToUse = (context.groupId && GroupSyncService.isGroupActive(context.groupId))
|
|
|
? context.groupId
|
|
|
: null;
|
|
|
|
|
|
// Crear tarea y asignaciones
|
|
|
const taskId = TaskService.createTask(
|
|
|
{
|
|
|
description: description || '',
|
|
|
due_date: dueDate ?? null,
|
|
|
group_id: groupIdToUse,
|
|
|
created_by: createdBy,
|
|
|
},
|
|
|
assignmentUserIds.map(uid => ({
|
|
|
user_id: uid,
|
|
|
assigned_by: createdBy,
|
|
|
}))
|
|
|
);
|
|
|
|
|
|
const mentionsForSending = assignmentUserIds.map(uid => `${uid}@s.whatsapp.net`);
|
|
|
|
|
|
// Resolver nombres útiles
|
|
|
const creatorName = await ContactsService.getDisplayName(createdBy);
|
|
|
const creatorJid = `${createdBy}@s.whatsapp.net`;
|
|
|
const groupName = groupIdToUse ? GroupSyncService.activeGroupsCache.get(groupIdToUse) : null;
|
|
|
|
|
|
const assignedDisplayNames = await Promise.all(
|
|
|
assignmentUserIds.map(async uid => {
|
|
|
const name = await ContactsService.getDisplayName(uid);
|
|
|
return name || uid;
|
|
|
})
|
|
|
);
|
|
|
|
|
|
const responses: CommandResponse[] = [];
|
|
|
|
|
|
// 1) Ack al creador con formato compacto
|
|
|
const dueFmt = formatDDMM(dueDate);
|
|
|
const ownerPart = assignmentUserIds.length === 0
|
|
|
? `${ICONS.unassigned} sin responsable${groupName ? ` (${groupName})` : ''}`
|
|
|
: `${assignmentUserIds.length > 1 ? '👥' : '👤'} ${assignedDisplayNames.join(', ')}`;
|
|
|
const ackParts = [
|
|
|
`${ICONS.create} ${codeId(taskId)} _${description || '(sin descripción)'}_`,
|
|
|
dueFmt ? `${ICONS.date} ${dueFmt}` : null,
|
|
|
ownerPart
|
|
|
].filter(Boolean);
|
|
|
responses.push({
|
|
|
recipient: createdBy,
|
|
|
message: ackParts.join(' — '),
|
|
|
mentions: mentionsForSending.length > 0 ? mentionsForSending : undefined
|
|
|
});
|
|
|
|
|
|
// 2) DM a cada asignado (excluyendo al creador para evitar duplicados)
|
|
|
for (const uid of assignmentUserIds) {
|
|
|
if (uid === createdBy) continue;
|
|
|
responses.push({
|
|
|
recipient: uid,
|
|
|
message: [
|
|
|
`${ICONS.assignNotice} ${codeId(taskId)}`,
|
|
|
`${description || '(sin descripción)'}`,
|
|
|
formatDDMM(dueDate) ? `${ICONS.date} ${formatDDMM(dueDate)}` : null,
|
|
|
groupName ? `Grupo: ${groupName}` : null,
|
|
|
italic(`Acciones: Completar → /t x ${taskId} · Soltar → /t soltar ${taskId}`)
|
|
|
].filter(Boolean).join('\n'),
|
|
|
mentions: [creatorJid]
|
|
|
});
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
return responses;
|
|
|
}
|
|
|
|
|
|
static async handle(context: CommandContext): Promise<CommandResponse[]> {
|
|
|
const msg = (context.message || '').trim();
|
|
|
if (!/^\/(tarea|t)\b/i.test(msg)) {
|
|
|
return [];
|
|
|
}
|
|
|
|
|
|
try {
|
|
|
return await this.processTareaCommand(context);
|
|
|
} catch (error) {
|
|
|
return [{
|
|
|
recipient: context.sender,
|
|
|
message: 'Error processing command'
|
|
|
}];
|
|
|
}
|
|
|
}
|
|
|
}
|