JCC-CSScheduler/common/pkgs/db/access.go

package db

import (
	"fmt"
	sch "gitlink.org.cn/cloudream/common/sdks/pcmscheduler"
	cdssdk "gitlink.org.cn/cloudream/common/sdks/storage"
	uploadersdk "gitlink.org.cn/cloudream/common/sdks/uploader"
)

type AccessDB struct {
	*DB
}

func (db *DB) Access() *AccessDB {
	return &AccessDB{DB: db}
}

func (db *AccessDB) CreateAccessRequest(ctx SQLContext, ret sch.PermissionApply) error {
	if err := ctx.Table("accessRequests").Create(&ret).Error; err != nil {
		return err
	}
	return nil
}

func (db *AccessDB) GetAccessRequestByID(ctx SQLContext, id int64) (sch.AccessRequest, error) {
	var ret sch.AccessRequest
	if err := ctx.Table("accessRequests").Where("id = ?", id).First(&ret).Error; err != nil {
		return ret, err
	}
	return ret, nil
}

func (db *AccessDB) GetAccessRequestByBindingID(ctx SQLContext, applicantID cdssdk.UserID, ownerID cdssdk.UserID, id int64, status []string) (sch.AccessRequest, error) {
	var ret sch.AccessRequest
	if applicantID != -1 {
		if err := ctx.Table("accessRequests").Where("binding_id = ? and applicant_id = ? and status not in ?", id, applicantID, status).First(&ret).Error; err != nil {
			return ret, err
		}
	}

	if ownerID != -1 {
		if err := ctx.Table("accessRequests").Where("binding_id = ? and data_owner_id = ? and status in ?", id, ownerID, status).First(&ret).Error; err != nil {
			return ret, err
		}
	}

	return ret, nil
}

func (db *AccessDB) GetAccessRequest(ctx SQLContext, userID cdssdk.UserID, dataType string) ([]uploadersdk.BindingAccessData, error) {
	var ret []uploadersdk.BindingAccessData
	sql := `
		select 
			ar.id as ID,
			bd.user_id,
			bd.name,
			bd.data_type,
			bd.content,
			bd.access_level,
			ar.applicant_id,
			ar.status,
			usr.username,
			usr.sso_id
		from
			(
			select
				id,
				data_owner_id as user_id,
				applicant_id,
				binding_id,
				status
			from
				accessRequests
			where data_owner_id = ?
			and status in ?
		) as ar
		left join (
			select
				*
			from
				BindingData
			where
				user_id = ?
				and data_type = ?
				and access_level = ?
		) as bd on
			bd.user_id = ar.user_id
			and bd.id = ar.binding_id
		left join (
		    select * from users
		) as usr on 
			bd.user_id = usr.id
		`
	status := []string{sch.PendingStatus, sch.ApprovedStatus, sch.RejectedStatus}
	err := ctx.Raw(sql, userID, status, userID, dataType, sch.ApplyAccess).Scan(&ret).Error
	if err != nil {
		return ret, err
	}
	return ret, nil
}

func (db *AccessDB) UpdateStatusByID(ctx SQLContext, id int64, status string, reason string) error {
	if status == sch.RejectedStatus {
		err := ctx.Table("accessRequests").Where("id = ?", id).Update("status", status).Update("reject_reason", reason).Error
		if err != nil {
			return err
		}
	} else {
		err := ctx.Table("accessRequests").Where("id = ?", id).Update("status", status).Error
		if err != nil {
			return err
		}
	}
	return nil
}

func (db *AccessDB) UpdateStatusByBindingID(ctx SQLContext, id uploadersdk.DataID, oldStatus string, newStatus string) error {
	err := ctx.Table("accessRequests").Where("binding_id = ? and status = ?", id, oldStatus).Update("status", newStatus).Error
	if err != nil {
		return err
	}
	return nil
}

func (db *AccessDB) CreateAccessLog(ctx SQLContext, ret sch.AccessLog) error {
	return ctx.Table("accessLogs").Create(ret).Error
}

func (db *AccessDB) GetUserBySsoID(ctx SQLContext, id string) (cdssdk.UserID, error) {
	var ret cdssdk.UserID

	sql := `
		select 
			id
		from
			users
		where
			sso_id = ?
	`
	err := ctx.Raw(sql, id).Scan(&ret).Error
	if err != nil {
		return ret, err
	}

	if ret == 0 {
		return ret, fmt.Errorf("user not found")
	}

	return ret, nil
}

func (db *AccessDB) AddUser(ctx SQLContext, user sch.User, buckets []sch.Bucket) error {
	// 根据ssoID查询数据是否存在
	var existUser sch.User
	err := ctx.Table("users").Where("sso_id = ?", user.SsoID).Find(&existUser).Error
	if err != nil {
		return err
	}
	if existUser.ID != 0 {
		return fmt.Errorf("user already exists")
	}

	tx := ctx.Begin()
	err = tx.Table("users").Create(&user).Error
	if err != nil {
		tx.Rollback()
		return err
	}

	for _, bucket := range buckets {
		err = tx.Table("bucket").Create(&bucket).Error
		if err != nil {
			tx.Rollback()
			return err
		}
	}
	tx.Commit()

	return nil
}

func (db *AccessDB) UpdateUser(ctx SQLContext, id string, username string) error {
	return ctx.Table("users").Where("sso_id = ?", id).Update("username", username).Error
}

func (db *AccessDB) GetBucketByUserID(ctx SQLContext, userID cdssdk.UserID, dataType string) (*sch.Bucket, error) {
	var ret sch.Bucket
	if err := ctx.Table("bucket").Where("user_id = ? and data_type = ?", userID, dataType).First(&ret).Error; err != nil {
		return &ret, err
	}
	return &ret, nil
}