web-next: /restore-character y /restore-items con todas las condiciones

- /restore-character: recupera personajes borrados por BD (como .character deleted restore). Condiciones: nivel>60, borrado <30 días, DK no si ya hay DK activo, nombre libre, cooldown 12h/personaje. Gratis. Tabla home_restorehistory. - /restore-items: recupera ítems borrados vía SOAP del core (.item restore list / .item restore); el core aplica calidad/equipable/BoP/<7días. Cada ítem 100 PD (reembolso si SOAP falla), consulta con cooldown 8h/personaje + Turnstile. Tabla home_itemsearchhistory. Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
2026-07-14 13:09:11 +00:00
parent d95fa932f9
commit 03f75e189c
11 changed files with 671 additions and 0 deletions
@@ -0,0 +1,112 @@
+import type { RowDataPacket, ResultSetHeader } from 'mysql2'
+import { db, DB } from './db'
+import { getClassCss } from './character-info'
+
+/**
+ * Recuperar personaje (/restore-character): restaura un personaje borrado.
+ * En AzerothCore un personaje borrado queda en `characters` con account=0,
+ * deleteInfos_Account/deleteInfos_Name = dueño/nombre originales y deleteDate
+ * (unix, segundos). Condiciones: nivel > 60, borrado hace < 30 días, y para
+ * Caballeros de la Muerte, la cuenta no puede tener ya un DK activo. 12 h/personaje.
+ */
+
+const MAX_AGE_S = 30 * 24 * 60 * 60
+const COOLDOWN_MS = 12 * 60 * 60 * 1000
+
+export interface DeletedCharacter {
+  guid: number
+  name: string
+  level: number
+  classCss: string
+}
+
+/** Personajes borrados de la cuenta que cumplen las condiciones (nivel>60, <30 días). */
+export async function getRestorableCharacters(accountId: number): Promise<DeletedCharacter[]> {
+  if (!accountId) return []
+  try {
+    const nowS = Math.floor(Date.now() / 1000)
+    const [rows] = await db(DB.characters).query<RowDataPacket[]>(
+      'SELECT guid, deleteInfos_Name AS name, level, class FROM characters ' +
+        'WHERE deleteInfos_Account = ? AND deleteDate IS NOT NULL AND deleteDate <> 0 ' +
+        'AND level > 60 AND deleteDate > ? ORDER BY deleteDate DESC',
+      [accountId, nowS - MAX_AGE_S],
+    )
+    return rows.map((r) => ({ guid: Number(r.guid), name: r.name, level: r.level, classCss: getClassCss(r.class) }))
+  } catch {
+    return []
+  }
+}
+
+export interface Result {
+  success: boolean
+  error?: string
+  name?: string
+}
+
+export async function restoreCharacter(accountId: number, guid: number): Promise<Result> {
+  if (!accountId || !Number.isInteger(guid) || guid <= 0) return { success: false, error: 'invalidRequest' }
+
+  let name = ''
+  let cls = 0
+  try {
+    const [rows] = await db(DB.characters).query<RowDataPacket[]>(
+      'SELECT deleteInfos_Name AS name, deleteInfos_Account, deleteDate, level, class FROM characters WHERE guid = ? LIMIT 1',
+      [guid],
+    )
+    const c = rows[0]
+    if (!c || Number(c.deleteInfos_Account) !== accountId) return { success: false, error: 'notFound' }
+    if (!c.deleteDate || Number(c.deleteDate) === 0) return { success: false, error: 'notDeleted' }
+    if (Number(c.level) <= 60) return { success: false, error: 'levelTooLow' }
+    if (Number(c.deleteDate) < Math.floor(Date.now() / 1000) - MAX_AGE_S) return { success: false, error: 'tooOld' }
+    name = String(c.name)
+    cls = Number(c.class)
+  } catch {
+    return { success: false, error: 'genericError' }
+  }
+
+  // Caballero de la Muerte: no restaurar si ya hay un DK activo en la cuenta.
+  if (cls === 6) {
+    const [dk] = await db(DB.characters).query<RowDataPacket[]>(
+      'SELECT 1 FROM characters WHERE account = ? AND class = 6 AND (deleteDate IS NULL OR deleteDate = 0) LIMIT 1',
+      [accountId],
+    )
+    if (dk[0]) return { success: false, error: 'dkExists' }
+  }
+
+  // El nombre original debe estar libre (otro personaje activo podría tenerlo).
+  const [taken] = await db(DB.characters).query<RowDataPacket[]>(
+    'SELECT 1 FROM characters WHERE name = ? AND (deleteDate IS NULL OR deleteDate = 0) LIMIT 1',
+    [name],
+  )
+  if (taken[0]) return { success: false, error: 'nameTaken' }
+
+  // Cooldown de 12 h por personaje.
+  try {
+    const [last] = await db(DB.default).query<RowDataPacket[]>(
+      'SELECT used_at FROM home_restorehistory WHERE character_guid = ? ORDER BY used_at DESC LIMIT 1',
+      [guid],
+    )
+    if (last[0] && Date.now() - new Date(last[0].used_at).getTime() < COOLDOWN_MS) {
+      return { success: false, error: 'cooldown' }
+    }
+  } catch {
+    /* ignore */
+  }
+
+  // Restaura (igual que `.character deleted restore` del core).
+  try {
+    const [res] = await db(DB.characters).query<ResultSetHeader>(
+      "UPDATE characters SET account = ?, name = ?, deleteInfos_Account = 0, deleteInfos_Name = '', deleteDate = NULL " +
+        'WHERE guid = ? AND deleteInfos_Account = ? AND deleteDate IS NOT NULL AND deleteDate <> 0',
+      [accountId, name, guid, accountId],
+    )
+    if (res.affectedRows !== 1) return { success: false, error: 'genericError' }
+  } catch {
+    return { success: false, error: 'genericError' }
+  }
+
+  await db(DB.default)
+    .query('INSERT INTO home_restorehistory (character_guid, used_at) VALUES (?, NOW())', [guid])
+    .catch(() => {})
+  return { success: true, name }
+}
@@ -0,0 +1,112 @@
+import type { RowDataPacket } from 'mysql2'
+import { db, DB } from './db'
+import { executeSoapCommand } from './soap'
+import { getGameCharacters } from './characters'
+
+/**
+ * Recuperar ítems (/restore-items): usa el sistema de recuperación de AzerothCore
+ * por SOAP. `.item restore list <char>` lista los ítems borrados recuperables (el
+ * core aplica las condiciones: calidad Raro+, equipable, se liga al recoger,
+ * borrado < 7 días). `.item restore <recoverId> <char>` restaura uno. Cada
+ * restauración cuesta **100 PD**. La consulta tiene cooldown de 8 h por personaje.
+ */
+
+export const RESTORE_ITEM_PD = 100
+const SEARCH_COOLDOWN_MS = 8 * 60 * 60 * 1000
+const SAFE_NAME = /^[A-Za-z]{1,12}$/
+
+export interface DeletedItem {
+  recoverId: number
+  itemId: number
+  name: string
+  count: number
+}
+
+/** Parsea la salida de `.item restore list` (líneas "Recover id: X | Item: NAME (ID) | Count: N"). */
+export function parseRecoverList(soap: string): DeletedItem[] {
+  const items: DeletedItem[] = []
+  const re = /Recover id:\s*(\d+)\s*\|\s*Item:\s*(.+?)\s*\((\d+)\)\s*\|\s*Count:\s*(\d+)/g
+  let m: RegExpExecArray | null
+  while ((m = re.exec(soap)) !== null) {
+    items.push({ recoverId: Number(m[1]), name: m[2].trim(), itemId: Number(m[3]), count: Number(m[4]) })
+  }
+  return items
+}
+
+async function ownsCharacter(accountId: number, character: string): Promise<boolean> {
+  if (!SAFE_NAME.test(character)) return false
+  const chars = await getGameCharacters(accountId)
+  return chars.some((c) => c.name === character)
+}
+
+export interface ListResult {
+  success: boolean
+  error?: string
+  minutes?: number
+  items?: DeletedItem[]
+}
+
+/** Lista los ítems borrados recuperables de un personaje (cooldown 8 h). */
+export async function listDeletedItems(accountId: number, character: string): Promise<ListResult> {
+  if (!(await ownsCharacter(accountId, character))) return { success: false, error: 'characterNotOwned' }
+
+  // Cooldown de 8 h por personaje.
+  try {
+    const [last] = await db(DB.default).query<RowDataPacket[]>(
+      'SELECT used_at FROM home_itemsearchhistory WHERE character_name = ? ORDER BY used_at DESC LIMIT 1',
+      [character],
+    )
+    if (last[0]) {
+      const diff = Date.now() - new Date(last[0].used_at).getTime()
+      if (diff < SEARCH_COOLDOWN_MS) {
+        return { success: false, error: 'cooldown', minutes: Math.ceil((SEARCH_COOLDOWN_MS - diff) / 60000) }
+      }
+    }
+  } catch {
+    /* ignore */
+  }
+
+  const soap = await executeSoapCommand(`.item restore list ${character}`)
+  if (soap === null) return { success: false, error: 'soapError' }
+
+  await db(DB.default)
+    .query('INSERT INTO home_itemsearchhistory (character_name, used_at) VALUES (?, NOW())', [character])
+    .catch(() => {})
+  return { success: true, items: parseRecoverList(soap) }
+}
+
+export interface RestoreResult {
+  success: boolean
+  error?: string
+  name?: string
+}
+
+/** Restaura un ítem borrado (cuesta 100 PD; reembolsa si el SOAP falla). */
+export async function restoreItem(accountId: number, character: string, recoverId: number): Promise<RestoreResult> {
+  if (!(await ownsCharacter(accountId, character))) return { success: false, error: 'characterNotOwned' }
+  if (!Number.isInteger(recoverId) || recoverId <= 0) return { success: false, error: 'invalidRequest' }
+
+  // Cobra 100 PD de forma atómica.
+  let charged = false
+  try {
+    const [res] = await db(DB.default).query(
+      'UPDATE home_api_points SET dp = dp - ? WHERE accountID = ? AND dp >= ?',
+      [RESTORE_ITEM_PD, accountId, RESTORE_ITEM_PD],
+    )
+    // @ts-expect-error affectedRows
+    charged = res.affectedRows === 1
+  } catch {
+    return { success: false, error: 'genericError' }
+  }
+  if (!charged) return { success: false, error: 'insufficientPoints' }
+
+  const soap = await executeSoapCommand(`.item restore ${recoverId} ${character}`)
+  if (soap === null) {
+    await db(DB.default)
+      .query('UPDATE home_api_points SET dp = dp + ? WHERE accountID = ?', [RESTORE_ITEM_PD, accountId])
+      .catch(() => {})
+    return { success: false, error: 'soapError' }
+  }
+
+  return { success: true }
+}