JCS-pub/client/internal/db/package.go

package db

import (
	"fmt"
	"time"

	"gitlink.org.cn/cloudream/storage2/client/types"
	"gorm.io/gorm"
)

type PackageDB struct {
	*DB
}

func (db *DB) Package() *PackageDB {
	return &PackageDB{DB: db}
}

func (db *PackageDB) GetByID(ctx SQLContext, packageID types.PackageID) (types.Package, error) {
	var ret types.Package
	err := ctx.Table("Package").Where("PackageID = ?", packageID).First(&ret).Error
	return ret, err
}

func (db *PackageDB) GetByName(ctx SQLContext, bucketID types.BucketID, name string) (types.Package, error) {
	var ret types.Package
	err := ctx.Table("Package").Where("BucketID = ? AND Name = ?", bucketID, name).First(&ret).Error
	return ret, err
}

func (db *PackageDB) BatchTestPackageID(ctx SQLContext, pkgIDs []types.PackageID) (map[types.PackageID]bool, error) {
	if len(pkgIDs) == 0 {
		return make(map[types.PackageID]bool), nil
	}

	var avaiIDs []types.PackageID
	err := ctx.Table("Package").
		Select("PackageID").
		Where("PackageID IN ?", pkgIDs).
		Find(&avaiIDs).Error
	if err != nil {
		return nil, err
	}

	avaiIDMap := make(map[types.PackageID]bool)
	for _, pkgID := range avaiIDs {
		avaiIDMap[pkgID] = true
	}

	return avaiIDMap, nil
}

func (*PackageDB) BatchGetAllPackageIDs(ctx SQLContext, start int, count int) ([]types.PackageID, error) {
	var ret []types.PackageID
	err := ctx.Table("Package").Select("PackageID").Limit(count).Offset(start).Find(&ret).Error
	return ret, err
}

func (db *PackageDB) GetBucketPackages(ctx SQLContext, bucketID types.BucketID) ([]types.Package, error) {
	var ret []types.Package
	err := ctx.Table("Package").
		Select("Package.*").
		Where("BucketID = ?", bucketID).
		Find(&ret).Error
	return ret, err
}

func (db *PackageDB) GetBucketPackagesByName(ctx SQLContext, bucketName string) ([]types.Package, error) {
	var ret []types.Package
	err := ctx.Table("Package").
		Select("Package.*").
		Joins("JOIN Bucket ON Package.BucketID = Bucket.BucketID").
		Where("Bucket.Name = ?", bucketName).
		Find(&ret).Error
	return ret, err
}

// 在指定名称的Bucket中查找指定名称的Package
func (*PackageDB) GetUserPackageByName(ctx SQLContext, bucketName string, packageName string) (types.Package, error) {
	var ret types.Package
	err := ctx.Table("Package").
		Select("Package.*").
		Joins("JOIN Bucket ON Package.BucketID = Bucket.BucketID").
		Where("Package.Name = ? AND Bucket.Name = ?", packageName, bucketName).
		First(&ret).Error
	return ret, err
}

func (db *PackageDB) Create(ctx SQLContext, bucketID types.BucketID, name string) (types.Package, error) {
	var packageID int64
	err := ctx.Table("Package").
		Select("PackageID").
		Where("Name = ? AND BucketID = ?", name, bucketID).
		Scan(&packageID).Error

	if err != nil {
		return types.Package{}, err
	}
	if packageID != 0 {
		return types.Package{}, gorm.ErrDuplicatedKey
	}

	newPackage := types.Package{Name: name, BucketID: bucketID, CreateTime: time.Now()}
	if err := ctx.Create(&newPackage).Error; err != nil {
		return types.Package{}, fmt.Errorf("insert package failed, err: %w", err)
	}

	return newPackage, nil
}

func (*PackageDB) Delete(ctx SQLContext, packageID types.PackageID) error {
	err := ctx.Delete(&types.Package{}, "PackageID = ?", packageID).Error
	return err
}

// 删除与Package相关的所有数据
func (db *PackageDB) DeleteComplete(ctx SQLContext, packageID types.PackageID) error {
	if err := db.Package().Delete(ctx, packageID); err != nil {
		return fmt.Errorf("delete package state: %w", err)
	}

	if err := db.ObjectAccessStat().DeleteInPackage(ctx, packageID); err != nil {
		return fmt.Errorf("delete from object access stat: %w", err)
	}

	if err := db.ObjectBlock().DeleteInPackage(ctx, packageID); err != nil {
		return fmt.Errorf("delete from object block failed, err: %w", err)
	}

	if err := db.PinnedObject().DeleteInPackage(ctx, packageID); err != nil {
		return fmt.Errorf("deleting pinned objects in package: %w", err)
	}

	if err := db.Object().DeleteInPackage(ctx, packageID); err != nil {
		return fmt.Errorf("deleting objects in package: %w", err)
	}

	if err := db.PackageAccessStat().DeleteByPackageID(ctx, packageID); err != nil {
		return fmt.Errorf("deleting package access stat: %w", err)
	}

	return nil
}

func (*PackageDB) ChangeState(ctx SQLContext, packageID types.PackageID, state string) error {
	err := ctx.Exec("UPDATE Package SET State = ? WHERE PackageID = ?", state, packageID).Error
	return err
}

func (*PackageDB) HasPackageIn(ctx SQLContext, bucketID types.BucketID) (bool, error) {
	var pkg types.Package
	err := ctx.Table("Package").Where("BucketID = ?", bucketID).First(&pkg).Error
	if err == gorm.ErrRecordNotFound {
		return false, nil
	}
	if err != nil {
		return false, err
	}
	return true, nil
}

func (*PackageDB) Move(ctx SQLContext, packageID types.PackageID, newBktID types.BucketID, newName string) error {
	err := ctx.Table("Package").Where("PackageID = ?", packageID).Update("BucketID", newBktID).Update("Name", newName).Error
	return err
}