udeServer/internal/model/tlogrestorerecordmodel.go

package model

import (
	"context"
	"database/sql"
	"fmt"
	"strings"
	"time"

	"github.com/zeromicro/go-zero/core/stores/sqlx"
)

// TLogRestoreRecord is one archive-restore run booked against the archive
// it restores.
type TLogRestoreRecord struct {
	Id             int64          `db:"id"`              // 主键
	ArchiveId      int64          `db:"archive_id"`      // 归档记录ID
	RestoreStatus  int64          `db:"restore_status"`  // 恢复状态:1-成功,2-失败,3-处理中
	RestoreMessage sql.NullString `db:"restore_message"` // 恢复说明或错误原因
	RestoredBy     string         `db:"restored_by"`     // 恢复人账号
	RestoredAt     time.Time      `db:"restored_at"`     // 恢复时间
}

// LogRestoreFilter mirrors LogRestoreReq; empty fields = no filtering.
type LogRestoreFilter struct {
	RestoreStatus  int64
	RestoreMessage string
}

type TLogRestoreRecordModel interface {
	// Insert books a new restore run and returns the insert result.
	Insert(ctx context.Context, data *TLogRestoreRecord) (sql.Result, error)
	// UpdateResult updates status and message of a restore run.
	UpdateResult(ctx context.Context, id int64, status int64, message sql.NullString) error
	// FindPage lists restore runs with optional filters, newest first.
	FindPage(ctx context.Context, page, pageSize int64, f LogRestoreFilter) ([]TLogRestoreRecord, int64, error)
}

type customTLogRestoreRecordModel struct {
	conn  sqlx.SqlConn
	table string
}

var _ TLogRestoreRecordModel = (*customTLogRestoreRecordModel)(nil)

// NewTLogRestoreRecordModel returns the model for t_log_restore_record.
func NewTLogRestoreRecordModel(conn sqlx.SqlConn) TLogRestoreRecordModel {
	return &customTLogRestoreRecordModel{
		conn:  conn,
		table: "`t_log_restore_record`",
	}
}

func (m *customTLogRestoreRecordModel) Insert(ctx context.Context, data *TLogRestoreRecord) (sql.Result, error) {
	query := "insert into t_log_restore_record (`archive_id`, `restore_status`, `restore_message`, `restored_by`) values (?, ?, ?, ?)"
	ret, err := m.conn.ExecCtx(ctx, query,
		data.ArchiveId, data.RestoreStatus, data.RestoreMessage, data.RestoredBy)
	return ret, err
}

func (m *customTLogRestoreRecordModel) UpdateResult(ctx context.Context, id int64, status int64, message sql.NullString) error {
	query := "update t_log_restore_record set `restore_status` = ?, `restore_message` = ? where `id` = ?"
	if _, err := m.conn.ExecCtx(ctx, query, status, message, id); err != nil {
		return err
	}
	return nil
}

func (m *customTLogRestoreRecordModel) FindPage(ctx context.Context, page, pageSize int64, f LogRestoreFilter) ([]TLogRestoreRecord, int64, error) {
	var conds []string
	var args []any

	if f.RestoreStatus != 0 {
		conds = append(conds, "`restore_status` = ?")
		args = append(args, f.RestoreStatus)
	}
	if f.RestoreMessage != "" {
		conds = append(conds, "`restore_message` like ? escape '\\\\'")
		args = append(args, "%"+escapeLike(f.RestoreMessage)+"%")
	}

	where := ""
	if len(conds) > 0 {
		where = " where " + strings.Join(conds, " and ")
	}

	var total int64
	if err := m.conn.QueryRowCtx(ctx, &total, fmt.Sprintf("select count(*) from %s%s", m.table, where), args...); err != nil {
		return nil, 0, err
	}

	if total == 0 {
		return nil, 0, nil
	}

	offset := (page - 1) * pageSize
	args = append(args, pageSize, offset)
	query := fmt.Sprintf(
		"select `id`, `archive_id`, `restore_status`, `restore_message`, `restored_by`, `restored_at` from %s%s order by `restored_at` desc limit ? offset ?",
		m.table, where)

	var resp []TLogRestoreRecord
	if err := m.conn.QueryRowsCtx(ctx, &resp, query, args...); err != nil {
		return nil, 0, err
	}

	return resp, total, nil
}