Files
Enterprise-Knowledge-Base/internal/application/repository/datasource_repo.go
T
wizardchen 1a340a8374 refactor(datasource): remove WeCom document integration and related components
- Deleted WeCom document connector and callback handling code to streamline the datasource management.
- Removed associated localization entries and UI elements related to WeCom integration.
- Updated data source management logic to eliminate references to WeCom, enhancing maintainability and clarity.
- Adjusted error handling and logging to reflect the removal of WeCom-specific functionality.
2026-03-30 20:46:07 +08:00

254 lines
6.8 KiB
Go

package repository
import (
"context"
"errors"
"time"
"github.com/Tencent/WeKnora/internal/types"
"github.com/Tencent/WeKnora/internal/types/interfaces"
"gorm.io/gorm"
)
// DataSourceRepository provides data access for data sources
type DataSourceRepository struct {
db *gorm.DB
}
// NewDataSourceRepository creates a new data source repository
func NewDataSourceRepository(db *gorm.DB) interfaces.DataSourceRepository {
return &DataSourceRepository{db: db}
}
// Create inserts a new data source record
func (r *DataSourceRepository) Create(ctx context.Context, ds *types.DataSource) error {
if ds == nil {
return errors.New("data source is nil")
}
if err := r.db.WithContext(ctx).Create(ds).Error; err != nil {
return err
}
return nil
}
// FindByID retrieves a data source by ID
func (r *DataSourceRepository) FindByID(ctx context.Context, id string) (*types.DataSource, error) {
if id == "" {
return nil, errors.New("id is empty")
}
var ds types.DataSource
if err := r.db.WithContext(ctx).
Where("id = ?", id).
Where("deleted_at IS NULL").
First(&ds).Error; err != nil {
if errors.Is(err, gorm.ErrRecordNotFound) {
return nil, errors.New("data source not found")
}
return nil, err
}
return &ds, nil
}
// FindByKnowledgeBase lists all data sources for a knowledge base
func (r *DataSourceRepository) FindByKnowledgeBase(ctx context.Context, kbID string) ([]*types.DataSource, error) {
if kbID == "" {
return nil, errors.New("knowledge base id is empty")
}
var dataSources []*types.DataSource
if err := r.db.WithContext(ctx).
Where("knowledge_base_id = ?", kbID).
Where("deleted_at IS NULL").
Order("created_at DESC").
Find(&dataSources).Error; err != nil {
return nil, err
}
return dataSources, nil
}
// Update updates an existing data source
func (r *DataSourceRepository) Update(ctx context.Context, ds *types.DataSource) error {
if ds == nil {
return errors.New("data source is nil")
}
if ds.ID == "" {
return errors.New("data source id is empty")
}
if err := r.db.WithContext(ctx).
Model(ds).
Updates(ds).Error; err != nil {
return err
}
return nil
}
// Delete performs a soft delete
func (r *DataSourceRepository) Delete(ctx context.Context, id string) error {
if id == "" {
return errors.New("id is empty")
}
if err := r.db.WithContext(ctx).
Model(&types.DataSource{}).
Where("id = ?", id).
Update("deleted_at", gorm.Expr("NOW()")).Error; err != nil {
return err
}
return nil
}
// FindActive retrieves all active data sources (used for scheduling)
func (r *DataSourceRepository) FindActive(ctx context.Context) ([]*types.DataSource, error) {
var dataSources []*types.DataSource
if err := r.db.WithContext(ctx).
Where("status = ?", types.DataSourceStatusActive).
Where("deleted_at IS NULL").
Where("sync_schedule != ''").
Order("created_at DESC").
Find(&dataSources).Error; err != nil {
return nil, err
}
return dataSources, nil
}
// SyncLogRepository provides data access for sync logs
type SyncLogRepository struct {
db *gorm.DB
}
// NewSyncLogRepository creates a new sync log repository
func NewSyncLogRepository(db *gorm.DB) interfaces.SyncLogRepository {
return &SyncLogRepository{db: db}
}
// Create inserts a new sync log entry
func (r *SyncLogRepository) Create(ctx context.Context, log *types.SyncLog) error {
if log == nil {
return errors.New("sync log is nil")
}
if err := r.db.WithContext(ctx).Create(log).Error; err != nil {
return err
}
return nil
}
// FindByID retrieves a sync log by ID
func (r *SyncLogRepository) FindByID(ctx context.Context, id string) (*types.SyncLog, error) {
if id == "" {
return nil, errors.New("id is empty")
}
var log types.SyncLog
if err := r.db.WithContext(ctx).
Where("id = ?", id).
First(&log).Error; err != nil {
if errors.Is(err, gorm.ErrRecordNotFound) {
return nil, errors.New("sync log not found")
}
return nil, err
}
return &log, nil
}
// FindByDataSource lists sync logs for a data source with pagination
func (r *SyncLogRepository) FindByDataSource(ctx context.Context, dsID string, limit int, offset int) ([]*types.SyncLog, error) {
if dsID == "" {
return nil, errors.New("data source id is empty")
}
if limit <= 0 {
limit = 10
}
if offset < 0 {
offset = 0
}
var logs []*types.SyncLog
if err := r.db.WithContext(ctx).
Where("data_source_id = ?", dsID).
Order("started_at DESC").
Limit(limit).
Offset(offset).
Find(&logs).Error; err != nil {
return nil, err
}
return logs, nil
}
// FindLatest retrieves the most recent sync log for a data source
func (r *SyncLogRepository) FindLatest(ctx context.Context, dsID string) (*types.SyncLog, error) {
if dsID == "" {
return nil, errors.New("data source id is empty")
}
var log types.SyncLog
if err := r.db.WithContext(ctx).
Where("data_source_id = ?", dsID).
Order("started_at DESC").
Limit(1).
First(&log).Error; err != nil {
if errors.Is(err, gorm.ErrRecordNotFound) {
return nil, nil
}
return nil, err
}
return &log, nil
}
// HasRunningSync checks if a data source has any sync currently in "running" status.
func (r *SyncLogRepository) HasRunningSync(ctx context.Context, dsID string) (bool, error) {
if dsID == "" {
return false, errors.New("data source id is empty")
}
var count int64
if err := r.db.WithContext(ctx).
Model(&types.SyncLog{}).
Where("data_source_id = ?", dsID).
Where("status = ?", types.SyncLogStatusRunning).
Count(&count).Error; err != nil {
return false, err
}
return count > 0, nil
}
// Update updates an existing sync log entry
func (r *SyncLogRepository) Update(ctx context.Context, log *types.SyncLog) error {
if log == nil {
return errors.New("sync log is nil")
}
if log.ID == "" {
return errors.New("sync log id is empty")
}
if err := r.db.WithContext(ctx).
Model(log).
Updates(log).Error; err != nil {
return err
}
return nil
}
// CancelPendingByDataSource marks all non-terminal sync logs for a data source as canceled.
func (r *SyncLogRepository) CancelPendingByDataSource(ctx context.Context, dsID string) error {
if dsID == "" {
return errors.New("data source id is empty")
}
now := time.Now().UTC()
return r.db.WithContext(ctx).
Model(&types.SyncLog{}).
Where("data_source_id = ?", dsID).
Where("status IN ?", []string{types.SyncLogStatusRunning, "pending"}).
Updates(map[string]interface{}{
"status": types.SyncLogStatusCanceled,
"finished_at": &now,
"error_message": "data source deleted",
}).Error
}
// CleanupOldLogs deletes sync logs older than the retention period
func (r *SyncLogRepository) CleanupOldLogs(ctx context.Context, retentionDays int) error {
if retentionDays <= 0 {
retentionDays = 30
}
// Delete logs older than the retention period
if err := r.db.WithContext(ctx).
Where("started_at < NOW() - INTERVAL ? DAY", retentionDays).
Delete(&types.SyncLog{}).Error; err != nil {
return err
}
return nil
}