yunrui_asset/backend/utils/backupLog.js

const BackupLog = require('../models/BackupLog');
const fs = require('fs');

async function createLogEntry(options) {
  const { logType, description, backupType, includeFiles, compressed } = options;

  try {
    const log = await BackupLog.create({
      logType: logType || 'manual',
      status: 'pending',
      description: description || '',
      backupType: backupType || 'full',
      includeFiles: includeFiles || false,
      compressed: compressed || false,
      startTime: new Date(),
    });
    return log;
  } catch (error) {
    console.error('创建备份日志失败:', error);
    return null;
  }
}

async function updateLogStatus(logId, status, options = {}) {
  try {
    const updateData = { status };

    if (status === 'running') {
      updateData.startTime = new Date();
    }

    if (status === 'success' || status === 'failed') {
      updateData.endTime = new Date();

      const log = await BackupLog.findByPk(logId);
      if (log && log.startTime) {
        updateData.duration = new Date() - new Date(log.startTime);
      }
    }

    if (options.filename) {
      updateData.filename = options.filename;
    }
    if (options.filePath) {
      updateData.filePath = options.filePath;
    }
    if (options.fileSize) {
      updateData.fileSize = options.fileSize;
    }
    if (options.errorMessage) {
      updateData.errorMessage = options.errorMessage;
    }
    if (options.remoteUploads) {
      updateData.remoteUploads = options.remoteUploads;
    }

    await BackupLog.update(updateData, {
      where: { id: logId },
    });

    return true;
  } catch (error) {
    console.error('更新备份日志失败:', error);
    return false;
  }
}

async function getBackupLogs(options = {}) {
  try {
    const { page = 1, pageSize = 20, logType, status } = options;
    const where = {};

    if (logType) {
      where.logType = logType;
    }
    if (status) {
      where.status = status;
    }

    const offset = (page - 1) * pageSize;

    const { count, rows } = await BackupLog.findAndCountAll({
      where,
      order: [['createdAt', 'DESC']],
      limit: pageSize,
      offset,
    });

    return {
      logs: rows,
      total: count,
      page,
      pageSize,
      totalPages: Math.ceil(count / pageSize),
    };
  } catch (error) {
    console.error('获取备份日志失败:', error);
    return { logs: [], total: 0, page: 1, pageSize: 20, totalPages: 0 };
  }
}

async function getBackupLogById(id) {
  try {
    return await BackupLog.findByPk(id);
  } catch (error) {
    console.error('获取备份日志详情失败:', error);
    return null;
  }
}

async function deleteOldLogs(days = 30) {
  try {
    const cutoffDate = new Date();
    cutoffDate.setDate(cutoffDate.getDate() - days);

    const deletedCount = await BackupLog.destroy({
      where: {
        createdAt: {
          [require('sequelize').Op.lt]: cutoffDate,
        },
      },
    });

    console.log(`删除了 ${deletedCount} 条旧备份日志`);
    return deletedCount;
  } catch (error) {
    console.error('删除旧备份日志失败:', error);
    return 0;
  }
}

module.exports = {
  createLogEntry,
  updateLogStatus,
  getBackupLogs,
  getBackupLogById,
  deleteOldLogs,
};