migrate from github

2026-07-15 22:42:31 +08:00
commit 3ad559f05e
262 changed files with 21637 additions and 0 deletions
@@ -0,0 +1,32 @@
+package knowledge_base_repo
+
+import (
+	"github.com/XingfenD/yoresee_doc/internal/model"
+	"gorm.io/gorm"
+)
+
+type CreateKnowledgeBaseOperation struct {
+	repo          *KnowledgeBaseRepository
+	knowledgeBase *model.KnowledgeBase
+	tx            *gorm.DB
+}
+
+func (r *KnowledgeBaseRepository) Create(knowledgeBase *model.KnowledgeBase) (op *CreateKnowledgeBaseOperation) {
+	return &CreateKnowledgeBaseOperation{
+		repo:          r,
+		knowledgeBase: knowledgeBase,
+	}
+}
+
+func (op *CreateKnowledgeBaseOperation) WithTx(tx *gorm.DB) *CreateKnowledgeBaseOperation {
+	op.tx = tx
+	return op
+}
+
+func (op *CreateKnowledgeBaseOperation) Exec() error {
+	if op.tx == nil {
+		op.tx = op.repo.db
+	}
+
+	return op.tx.Create(op.knowledgeBase).Error
+}
@@ -0,0 +1,38 @@
+package knowledge_base_repo
+
+import (
+	"github.com/XingfenD/yoresee_doc/internal/model"
+	"gorm.io/gorm"
+	"gorm.io/gorm/clause"
+)
+
+type CreateRecentKnowledgeBaseOperation struct {
+	repo *KnowledgeBaseRepository
+	m    *model.RecentKnowledgeBase
+	tx   *gorm.DB
+}
+
+func (r *KnowledgeBaseRepository) CreateRecentKnowledgeBase(m *model.RecentKnowledgeBase) *CreateRecentKnowledgeBaseOperation {
+	return &CreateRecentKnowledgeBaseOperation{
+		repo: r,
+		m:    m,
+	}
+}
+
+func (op *CreateRecentKnowledgeBaseOperation) WithTx(tx *gorm.DB) {
+	op.tx = tx
+}
+
+func (op *CreateRecentKnowledgeBaseOperation) Exec() error {
+	if op.tx == nil {
+		op.tx = op.repo.db
+	}
+
+	return op.tx.Clauses(clause.OnConflict{
+		Columns: []clause.Column{
+			{Name: "user_id"},
+			{Name: "knowledge_base_id"},
+		},
+		DoUpdates: clause.AssignmentColumns([]string{"accessed_at"}),
+	}).Create(op.m).Error
+}
@@ -0,0 +1,32 @@
+package knowledge_base_repo
+
+import (
+	"github.com/XingfenD/yoresee_doc/internal/model"
+	"gorm.io/gorm"
+)
+
+type DeleteKnowledgeBaseOperation struct {
+	repo          *KnowledgeBaseRepository
+	knowledgeBase *model.KnowledgeBase
+	tx            *gorm.DB
+}
+
+func (r *KnowledgeBaseRepository) Delete(knowledgeBase *model.KnowledgeBase) (op *DeleteKnowledgeBaseOperation) {
+	return &DeleteKnowledgeBaseOperation{
+		repo:          r,
+		knowledgeBase: knowledgeBase,
+	}
+}
+
+func (op *DeleteKnowledgeBaseOperation) WithTx(tx *gorm.DB) *DeleteKnowledgeBaseOperation {
+	op.tx = tx
+	return op
+}
+
+func (op *DeleteKnowledgeBaseOperation) Exec() error {
+	if op.tx == nil {
+		op.tx = op.repo.db
+	}
+	err := op.tx.Delete(op.knowledgeBase).Error
+	return err
+}
@@ -0,0 +1,56 @@
+package knowledge_base_repo
+
+import (
+	"context"
+
+	cache_loader "github.com/XingfenD/yoresee_doc/internal/cache"
+	"github.com/XingfenD/yoresee_doc/internal/model"
+	"github.com/XingfenD/yoresee_doc/pkg/key"
+
+	"github.com/sirupsen/logrus"
+	"gorm.io/gorm"
+)
+
+type GetKnowledgeBaseByExternalIDOperation struct {
+	repo       *KnowledgeBaseRepository
+	externalID string
+	tx         *gorm.DB
+}
+
+func (r *KnowledgeBaseRepository) GetByExternalID(externalID string) (op *GetKnowledgeBaseByExternalIDOperation) {
+	return &GetKnowledgeBaseByExternalIDOperation{
+		repo:       r,
+		externalID: externalID,
+	}
+}
+
+func (op *GetKnowledgeBaseByExternalIDOperation) WithTx(tx *gorm.DB) *GetKnowledgeBaseByExternalIDOperation {
+	op.tx = tx
+	return op
+}
+
+func (op *GetKnowledgeBaseByExternalIDOperation) query(db *gorm.DB) (*model.KnowledgeBase, error) {
+	var knowledgeBase model.KnowledgeBase
+	err := db.First(&knowledgeBase, "external_id = ?", op.externalID).Error
+	return &knowledgeBase, err
+}
+
+func (op *GetKnowledgeBaseByExternalIDOperation) Exec() (*model.KnowledgeBase, error) {
+	if op.tx != nil {
+		return op.query(op.tx)
+	}
+
+	knowledgeBaseCacheKey := key.KeyModelByExternalID(key.KeyObjectTypeEnum_KnowledgeBase, op.externalID)
+	knowledgeBase, err := cache_loader.NewCacheLoadOperation[model.KnowledgeBase](&op.repo.Loader).
+		WithDBLoader(func() (*model.KnowledgeBase, error) {
+			return op.query(op.repo.db)
+		}).WithDefaultKeyAndParser(knowledgeBaseCacheKey, nil).
+		Exec(context.Background())
+
+	if err != nil {
+		logrus.Errorf("load data failed for GetKnowledgeBaseByExternalIDOperation: %+v", err)
+		return nil, err
+	}
+
+	return knowledgeBase, nil
+}
@@ -0,0 +1,32 @@
+package knowledge_base_repo
+
+import (
+	"github.com/XingfenD/yoresee_doc/internal/model"
+	"gorm.io/gorm"
+)
+
+type KnowledgeBaseGetByIDOperation struct {
+	repo *KnowledgeBaseRepository
+	id   int64
+	tx   *gorm.DB
+}
+
+func (r *KnowledgeBaseRepository) GetByID(id int64) (op *KnowledgeBaseGetByIDOperation) {
+	return &KnowledgeBaseGetByIDOperation{
+		repo: r,
+		id:   id,
+	}
+}
+
+func (op *KnowledgeBaseGetByIDOperation) WithTx(tx *gorm.DB) *KnowledgeBaseGetByIDOperation {
+	op.tx = tx
+	return op
+}
+
+func (op *KnowledgeBaseGetByIDOperation) Exec() (knowledgeBase *model.KnowledgeBase, err error) {
+	if op.tx == nil {
+		op.tx = op.repo.db
+	}
+	err = op.tx.First(knowledgeBase, "id = ?", op.id).Error
+	return
+}
@@ -0,0 +1,36 @@
+package knowledge_base_repo
+
+import (
+	"github.com/XingfenD/yoresee_doc/internal/model"
+	"gorm.io/gorm"
+)
+
+type KnowledgeBaseGetIDByExternalIDOperation struct {
+	repo       *KnowledgeBaseRepository
+	externalID string
+	tx         *gorm.DB
+}
+
+func (r *KnowledgeBaseRepository) GetIDByExternalID(externalID string) (op *KnowledgeBaseGetIDByExternalIDOperation) {
+	return &KnowledgeBaseGetIDByExternalIDOperation{
+		repo:       r,
+		externalID: externalID,
+	}
+}
+
+func (op *KnowledgeBaseGetIDByExternalIDOperation) WithTx(tx *gorm.DB) *KnowledgeBaseGetIDByExternalIDOperation {
+	op.tx = tx
+	return op
+}
+
+func (op *KnowledgeBaseGetIDByExternalIDOperation) Exec() (int64, error) {
+	var id int64
+	if op.tx == nil {
+		op.tx = op.repo.db
+	}
+	err := op.tx.Model(&model.KnowledgeBase{}).Where("external_id = ?", op.externalID).Pluck("id", &id).Error
+	if err != nil {
+		return 0, err
+	}
+	return id, nil
+}
@@ -0,0 +1,19 @@
+package knowledge_base_repo
+
+import (
+	cache_loader "github.com/XingfenD/yoresee_doc/internal/cache"
+	"github.com/redis/go-redis/v9"
+	"gorm.io/gorm"
+)
+
+type KnowledgeBaseRepository struct {
+	db     *gorm.DB
+	Loader cache_loader.Loader
+}
+
+func NewKnowledgeBaseRepository(db *gorm.DB, redis *redis.Client) *KnowledgeBaseRepository {
+	return &KnowledgeBaseRepository{
+		db:     db,
+		Loader: *cache_loader.NewLoader(redis),
+	}
+}
@@ -0,0 +1,154 @@
+package knowledge_base_repo
+
+import (
+	"github.com/XingfenD/yoresee_doc/internal/model"
+	"gorm.io/gorm"
+)
+
+type ListKnowledgeBaseOperation struct {
+	repo          *KnowledgeBaseRepository
+	model         *model.KnowledgeBase
+	creatorID     *int64
+	isPublic      *bool
+	nameKeyword   *string
+	createAtStart *string
+	createAtEnd   *string
+	updateAtStart *string
+	updateAtEnd   *string
+	sortField     string
+	sortDesc      bool
+	page          int
+	pageSize      int
+	tx            *gorm.DB
+}
+
+func (r *KnowledgeBaseRepository) List(m *model.KnowledgeBase) (op *ListKnowledgeBaseOperation) {
+	return &ListKnowledgeBaseOperation{
+		repo:  r,
+		model: m,
+	}
+}
+
+func (op *ListKnowledgeBaseOperation) WithTx(tx *gorm.DB) *ListKnowledgeBaseOperation {
+	op.tx = tx
+	return op
+}
+
+func (op *ListKnowledgeBaseOperation) WithCreatorID(creatorID *int64) *ListKnowledgeBaseOperation {
+	op.creatorID = creatorID
+	return op
+}
+
+func (op *ListKnowledgeBaseOperation) WithIsPublic(isPublic *bool) *ListKnowledgeBaseOperation {
+	op.isPublic = isPublic
+	return op
+}
+
+func (op *ListKnowledgeBaseOperation) WithNameKeyword(nameKeyword *string) *ListKnowledgeBaseOperation {
+	op.nameKeyword = nameKeyword
+	return op
+}
+
+func (op *ListKnowledgeBaseOperation) WithCreateTimeRange(start, end *string) *ListKnowledgeBaseOperation {
+	op.createAtStart = start
+	op.createAtEnd = end
+	return op
+}
+
+func (op *ListKnowledgeBaseOperation) WithUpdateTimeRange(start, end *string) *ListKnowledgeBaseOperation {
+	op.updateAtStart = start
+	op.updateAtEnd = end
+	return op
+}
+
+func (op *ListKnowledgeBaseOperation) WithSort(field string, desc bool) *ListKnowledgeBaseOperation {
+	op.sortField = field
+	op.sortDesc = desc
+	return op
+}
+
+func (op *ListKnowledgeBaseOperation) WithPagination(page, pageSize int) *ListKnowledgeBaseOperation {
+	op.page = page
+	op.pageSize = pageSize
+	return op
+}
+
+func (op *ListKnowledgeBaseOperation) Exec() (kbs []*model.KnowledgeBase, err error) {
+	if op.tx == nil {
+		op.tx = op.repo.db
+	}
+
+	dbQuery := op.tx.Model(op.model)
+
+	if op.model != nil {
+		dbQuery = dbQuery.Where(op.model)
+	}
+
+	if op.creatorID != nil {
+		dbQuery = dbQuery.Where("creator_user_id = ?", *op.creatorID)
+	}
+
+	if op.isPublic != nil {
+		dbQuery = dbQuery.Where("is_public = ?", *op.isPublic)
+	}
+
+	orderStr := "created_at DESC"
+	if op.sortField != "" {
+		if op.sortDesc {
+			orderStr = op.sortField + " DESC"
+		} else {
+			orderStr = op.sortField + " ASC"
+		}
+	}
+	dbQuery = dbQuery.Order(orderStr)
+
+	if op.page > 0 && op.pageSize > 0 {
+		offset := (op.page - 1) * op.pageSize
+		dbQuery = dbQuery.Offset(offset).Limit(op.pageSize)
+	}
+
+	err = dbQuery.Find(&kbs).Error
+	return
+}
+
+func (op *ListKnowledgeBaseOperation) ExecWithTotal() (kbs []*model.KnowledgeBase, total int64, err error) {
+	if op.tx == nil {
+		op.tx = op.repo.db
+	}
+
+	dbQuery := op.tx.Model(op.model)
+
+	if op.model != nil {
+		dbQuery = dbQuery.Where(op.model)
+	}
+
+	if op.creatorID != nil {
+		dbQuery = dbQuery.Where("creator_user_id = ?", *op.creatorID)
+	}
+
+	if op.isPublic != nil {
+		dbQuery = dbQuery.Where("is_public = ?", *op.isPublic)
+	}
+	err = dbQuery.Count(&total).Error
+	if err != nil {
+		return nil, 0, err
+	}
+
+	orderStr := "created_at DESC"
+	if op.sortField != "" {
+		if op.sortDesc {
+			orderStr = op.sortField + " DESC"
+		} else {
+			orderStr = op.sortField + " ASC"
+		}
+	}
+	dbQuery = dbQuery.Order(orderStr)
+
+	if op.page > 0 && op.pageSize > 0 {
+		offset := (op.page - 1) * op.pageSize
+		dbQuery = dbQuery.Offset(offset).Limit(op.pageSize)
+	}
+
+	err = dbQuery.Find(&kbs).Error
+	return
+}
@@ -0,0 +1,83 @@
+package knowledge_base_repo
+
+import (
+	"time"
+
+	"github.com/XingfenD/yoresee_doc/internal/model"
+
+	"gorm.io/gorm"
+)
+
+type ListRecentKnowledgeBasesOperation struct {
+	repo      *KnowledgeBaseRepository
+	userID    int64
+	startTime *time.Time
+	endTime   *time.Time
+	page      int
+	pageSize  int
+	tx        *gorm.DB
+}
+
+func (r *KnowledgeBaseRepository) ListRecentKnowledgeBases(userID int64) *ListRecentKnowledgeBasesOperation {
+	return &ListRecentKnowledgeBasesOperation{
+		repo:   r,
+		userID: userID,
+	}
+}
+
+func (op *ListRecentKnowledgeBasesOperation) WithTimeRange(start, end *time.Time) *ListRecentKnowledgeBasesOperation {
+	op.startTime = start
+	op.endTime = end
+	return op
+}
+
+func (op *ListRecentKnowledgeBasesOperation) WithPagination(page, pageSize int) *ListRecentKnowledgeBasesOperation {
+	op.page = page
+	op.pageSize = pageSize
+	return op
+}
+
+func (op *ListRecentKnowledgeBasesOperation) WithTx(tx *gorm.DB) *ListRecentKnowledgeBasesOperation {
+	op.tx = tx
+	return op
+}
+
+func (op *ListRecentKnowledgeBasesOperation) Exec() ([]*model.RecentKnowledgeBase, int64, error) {
+	db := op.repo.db
+	if op.tx != nil {
+		db = op.tx
+	}
+
+	query := db.Model(&model.RecentKnowledgeBase{}).
+		Where("user_id = ?", op.userID)
+	if op.startTime != nil {
+		query = query.Where("accessed_at >= ?", *op.startTime)
+	}
+	if op.endTime != nil {
+		query = query.Where("accessed_at <= ?", *op.endTime)
+	}
+
+	page := op.page
+	pageSize := op.pageSize
+	if page <= 0 {
+		page = 1
+	}
+	if pageSize <= 0 {
+		pageSize = 10
+	}
+	if pageSize > 100 {
+		pageSize = 100
+	}
+	offset := (page - 1) * pageSize
+
+	var total int64
+	if err := query.Count(&total).Error; err != nil {
+		return nil, 0, err
+	}
+
+	var records []*model.RecentKnowledgeBase
+	if err := query.Order("accessed_at DESC").Offset(offset).Limit(pageSize).Find(&records).Error; err != nil {
+		return nil, 0, err
+	}
+	return records, total, nil
+}
@@ -0,0 +1,39 @@
+package knowledge_base_repo
+
+import (
+	"github.com/XingfenD/yoresee_doc/internal/model"
+	"gorm.io/gorm"
+)
+
+type MGetKnowledgeBaseByIDsOperation struct {
+	repo *KnowledgeBaseRepository
+	ids  []int64
+	tx   *gorm.DB
+}
+
+func (r *KnowledgeBaseRepository) MGetKnowledgeBaseByIDs(ids []int64) *MGetKnowledgeBaseByIDsOperation {
+	return &MGetKnowledgeBaseByIDsOperation{
+		repo: r,
+		ids:  ids,
+	}
+}
+
+func (op *MGetKnowledgeBaseByIDsOperation) WithTx(tx *gorm.DB) *MGetKnowledgeBaseByIDsOperation {
+	op.tx = tx
+	return op
+}
+
+func (op *MGetKnowledgeBaseByIDsOperation) Exec() ([]*model.KnowledgeBase, error) {
+	if len(op.ids) == 0 {
+		return []*model.KnowledgeBase{}, nil
+	}
+	db := op.repo.db
+	if op.tx != nil {
+		db = op.tx
+	}
+	var kbs []*model.KnowledgeBase
+	if err := db.Model(&model.KnowledgeBase{}).Where("id IN ?", op.ids).Find(&kbs).Error; err != nil {
+		return nil, err
+	}
+	return kbs, nil
+}
@@ -0,0 +1,63 @@
+package knowledge_base_repo
+
+import (
+	"github.com/XingfenD/yoresee_doc/internal/model"
+	"gorm.io/gorm"
+)
+
+type MGetKnowledgeBaseDocumentsCountOperation struct {
+	repo             *KnowledgeBaseRepository
+	knowledgeBaseIDs []int64
+	tx               *gorm.DB
+}
+
+func (r *KnowledgeBaseRepository) MGetKnowledgeBaseDocumentsCount(knowledgeBaseIDs []int64) *MGetKnowledgeBaseDocumentsCountOperation {
+	return &MGetKnowledgeBaseDocumentsCountOperation{
+		repo:             r,
+		knowledgeBaseIDs: knowledgeBaseIDs,
+	}
+}
+
+func (op *MGetKnowledgeBaseDocumentsCountOperation) WithTx(tx *gorm.DB) *MGetKnowledgeBaseDocumentsCountOperation {
+	op.tx = tx
+	return op
+}
+
+func (op *MGetKnowledgeBaseDocumentsCountOperation) Exec() (map[int64]int64, error) {
+	result := make(map[int64]int64)
+
+	if len(op.knowledgeBaseIDs) == 0 {
+		return result, nil
+	}
+
+	if op.tx == nil {
+		op.tx = op.repo.db
+	}
+
+	var counts []struct {
+		KnowledgeID int64
+		Count       int64
+	}
+
+	err := op.tx.Model(&model.Document{}).
+		Select("knowledge_id, count(*) as count").
+		Where("knowledge_id IN ?", op.knowledgeBaseIDs).
+		Group("knowledge_id").
+		Find(&counts).Error
+
+	if err != nil {
+		return nil, err
+	}
+
+	for _, c := range counts {
+		result[c.KnowledgeID] = c.Count
+	}
+
+	for _, id := range op.knowledgeBaseIDs {
+		if _, exists := result[id]; !exists {
+			result[id] = 0
+		}
+	}
+
+	return result, nil
+}