spider/internal/store/merchant_repo.go

package store

import (
	"spider/internal/model"
	"spider/internal/plugin"
	"strings"

	"gorm.io/gorm"
)

// SaveRaw inserts a merchant into merchants_raw from plugin output.
// Dedup: same tg_username + same source_url => skip (via unique index).
// Returns true if a new record was inserted.
func (s *Store) SaveRaw(data plugin.MerchantData) (bool, error) {
	if strings.TrimSpace(data.TgUsername) == "" {
		return false, nil // no tg_username = don't insert
	}
	username := strings.TrimPrefix(strings.TrimSpace(data.TgUsername), "@")

	tgLink := data.TgLink
	if tgLink == "" && username != "" {
		tgLink = "https://t.me/" + username
	}

	// Truncate source_url to fit the unique index (255+500 chars × 4 bytes = 3020 < 3072)
	sourceURL := data.SourceURL
	if len(sourceURL) > 490 {
		sourceURL = sourceURL[:490]
	}

	raw := model.MerchantRaw{
		MerchantName: data.MerchantName,
		TgUsername:   username,
		TgLink:       tgLink,
		Website:      data.Website,
		Email:        data.Email,
		Phone:        data.Phone,
		IndustryTag:  data.IndustryTag,
		SourceType:   data.SourceType,
		SourceName:   data.SourceName,
		SourceURL:    sourceURL,
		OriginalText: data.OriginalText,
		Status:       "raw",
	}

	// Use unique index for dedup: insert only if (tg_username, source_url) doesn't exist
	result := s.DB.Where("tg_username = ? AND source_url = ?", username, sourceURL).
		FirstOrCreate(&raw)
	if result.Error != nil {
		return false, result.Error
	}
	// RowsAffected == 1 means a new record was created
	return result.RowsAffected > 0, nil
}

// ListRawByStatus returns raw merchants with the given status.
func (s *Store) ListRawByStatus(status string, limit int) ([]model.MerchantRaw, error) {
	var raws []model.MerchantRaw
	q := s.DB.Where("status = ?", status)
	if limit > 0 {
		q = q.Limit(limit)
	}
	err := q.Find(&raws).Error
	return raws, err
}

// UpdateRawStatus sets the status of a raw merchant.
func (s *Store) UpdateRawStatus(id uint, status string) error {
	return s.DB.Model(&model.MerchantRaw{}).Where("id = ?", id).Update("status", status).Error
}

// BatchUpdateRawStatus sets the status for multiple raw merchants in one query.
func (s *Store) BatchUpdateRawStatus(ids []uint, status string) error {
	if len(ids) == 0 {
		return nil
	}
	return s.DB.Model(&model.MerchantRaw{}).Where("id IN ?", ids).Update("status", status).Error
}

// SaveClean upserts a clean merchant by tg_username.
func (s *Store) SaveClean(m *model.MerchantClean) error {
	var existing model.MerchantClean
	err := s.DB.Where("tg_username = ?", m.TgUsername).First(&existing).Error
	if err == gorm.ErrRecordNotFound {
		return s.DB.Create(m).Error
	}
	if err != nil {
		return err
	}
	m.ID = existing.ID
	return s.DB.Save(m).Error
}

// ListClean returns paginated clean merchants with optional filters.
func (s *Store) ListClean(filters map[string]string, page, pageSize int) ([]model.MerchantClean, int64, error) {
	var merchants []model.MerchantClean
	var total int64

	q := s.DB.Model(&model.MerchantClean{})

	if v, ok := filters["status"]; ok && v != "" {
		q = q.Where("status = ?", v)
	}
	if v, ok := filters["level"]; ok && v != "" {
		q = q.Where("level = ?", v)
	}
	if v, ok := filters["industry_tag"]; ok && v != "" {
		q = q.Where("industry_tag = ?", v)
	}
	if v, ok := filters["search"]; ok && v != "" {
		like := "%" + v + "%"
		q = q.Where("tg_username LIKE ? OR merchant_name LIKE ?", like, like)
	}

	q.Count(&total)

	offset := (page - 1) * pageSize
	err := q.Order("created_at DESC").Offset(offset).Limit(pageSize).Find(&merchants).Error
	return merchants, total, err
}