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,56 @@
+package membership_repo
+
+import (
+	"github.com/XingfenD/yoresee_doc/internal/model"
+	"gorm.io/gorm"
+)
+
+type CreateUserGroupOperation struct {
+	repo  *MembershipRepository
+	group *model.UserGroupMeta
+	tx    *gorm.DB
+}
+
+func (r *MembershipRepository) CreateUserGroup(group *model.UserGroupMeta) *CreateUserGroupOperation {
+	return &CreateUserGroupOperation{
+		repo:  r,
+		group: group,
+	}
+}
+
+func (op *CreateUserGroupOperation) WithTx(tx *gorm.DB) *CreateUserGroupOperation {
+	op.tx = tx
+	return op
+}
+
+func (op *CreateUserGroupOperation) Exec() error {
+	if op.tx != nil {
+		return op.tx.Create(op.group).Error
+	}
+	return op.repo.db.Create(op.group).Error
+}
+
+type CreateOrgNodeOperation struct {
+	repo    *MembershipRepository
+	orgNode *model.OrgNodeMeta
+	tx      *gorm.DB
+}
+
+func (r *MembershipRepository) CreateOrgNode(orgNode *model.OrgNodeMeta) *CreateOrgNodeOperation {
+	return &CreateOrgNodeOperation{
+		repo:    r,
+		orgNode: orgNode,
+	}
+}
+
+func (op *CreateOrgNodeOperation) WithTx(tx *gorm.DB) *CreateOrgNodeOperation {
+	op.tx = tx
+	return op
+}
+
+func (op *CreateOrgNodeOperation) Exec() error {
+	if op.tx != nil {
+		return op.tx.Create(op.orgNode).Error
+	}
+	return op.repo.db.Create(op.orgNode).Error
+}
@@ -0,0 +1,56 @@
+package membership_repo
+
+import (
+	"github.com/XingfenD/yoresee_doc/internal/model"
+	"gorm.io/gorm"
+)
+
+type DeleteUserGroupOperation struct {
+	repo  *MembershipRepository
+	group *model.UserGroupMeta
+	tx    *gorm.DB
+}
+
+func (r *MembershipRepository) DeleteUserGroup(group *model.UserGroupMeta) *DeleteUserGroupOperation {
+	return &DeleteUserGroupOperation{
+		repo:  r,
+		group: group,
+	}
+}
+
+func (op *DeleteUserGroupOperation) WithTx(tx *gorm.DB) *DeleteUserGroupOperation {
+	op.tx = tx
+	return op
+}
+
+func (op *DeleteUserGroupOperation) Exec() error {
+	if op.tx != nil {
+		return op.tx.Delete(op.group).Error
+	}
+	return op.repo.db.Delete(op.group).Error
+}
+
+type DeleteOrgNodeOperation struct {
+	repo    *MembershipRepository
+	orgNode *model.OrgNodeMeta
+	tx      *gorm.DB
+}
+
+func (r *MembershipRepository) DeleteOrgNode(orgNode *model.OrgNodeMeta) *DeleteOrgNodeOperation {
+	return &DeleteOrgNodeOperation{
+		repo:    r,
+		orgNode: orgNode,
+	}
+}
+
+func (op *DeleteOrgNodeOperation) WithTx(tx *gorm.DB) *DeleteOrgNodeOperation {
+	op.tx = tx
+	return op
+}
+
+func (op *DeleteOrgNodeOperation) Exec() error {
+	if op.tx != nil {
+		return op.tx.Delete(op.orgNode).Error
+	}
+	return op.repo.db.Delete(op.orgNode).Error
+}
@@ -0,0 +1,68 @@
+package membership_repo
+
+import (
+	"github.com/XingfenD/yoresee_doc/internal/model"
+	"gorm.io/gorm"
+)
+
+type GetUserGroupByExternalIDOperation struct {
+	repo       *MembershipRepository
+	externalID string
+	tx         *gorm.DB
+}
+
+func (r *MembershipRepository) GetUserGroupByExternalID(externalID string) *GetUserGroupByExternalIDOperation {
+	return &GetUserGroupByExternalIDOperation{
+		repo:       r,
+		externalID: externalID,
+	}
+}
+
+func (op *GetUserGroupByExternalIDOperation) WithTx(tx *gorm.DB) *GetUserGroupByExternalIDOperation {
+	op.tx = tx
+	return op
+}
+
+func (op *GetUserGroupByExternalIDOperation) Exec() (*model.UserGroupMeta, error) {
+	var group model.UserGroupMeta
+	var err error
+
+	if op.tx != nil {
+		err = op.tx.Where("external_id = ?", op.externalID).First(&group).Error
+	} else {
+		err = op.repo.db.Where("external_id = ?", op.externalID).First(&group).Error
+	}
+
+	return &group, err
+}
+
+type GetOrgNodeByExternalID struct {
+	repo       *MembershipRepository
+	externalID string
+	tx         *gorm.DB
+}
+
+func (r *MembershipRepository) GetOrgNodeByExternalID(externalID string) *GetOrgNodeByExternalID {
+	return &GetOrgNodeByExternalID{
+		repo:       r,
+		externalID: externalID,
+	}
+}
+
+func (op *GetOrgNodeByExternalID) WithTx(tx *gorm.DB) *GetOrgNodeByExternalID {
+	op.tx = tx
+	return op
+}
+
+func (op *GetOrgNodeByExternalID) Exec() (*model.OrgNodeMeta, error) {
+	var orgNode model.OrgNodeMeta
+	var err error
+
+	if op.tx != nil {
+		err = op.tx.Where("external_id = ?", op.externalID).First(&orgNode).Error
+	} else {
+		err = op.repo.db.Where("external_id = ?", op.externalID).First(&orgNode).Error
+	}
+
+	return &orgNode, err
+}
@@ -0,0 +1,62 @@
+package membership_repo
+
+import (
+	"github.com/XingfenD/yoresee_doc/internal/model"
+	"gorm.io/gorm"
+)
+
+type GetUserGroupIDByExternalIDOperation struct {
+	repo       *MembershipRepository
+	externalID string
+	tx         *gorm.DB
+}
+
+func (r *MembershipRepository) GetUserGroupIDByExternalID(externalID string) *GetUserGroupIDByExternalIDOperation {
+	return &GetUserGroupIDByExternalIDOperation{
+		repo:       r,
+		externalID: externalID,
+	}
+}
+
+func (op *GetUserGroupIDByExternalIDOperation) WithTx(tx *gorm.DB) *GetUserGroupIDByExternalIDOperation {
+	op.tx = tx
+	return op
+}
+
+func (op *GetUserGroupIDByExternalIDOperation) Exec() (int64, error) {
+	var id int64
+	var err error
+	if op.tx != nil {
+		err = op.tx.Model(&model.UserGroupMeta{}).Where("external_id = ?", op.externalID).Pluck("id", &id).Error
+	}
+	err = op.repo.db.Model(&model.UserGroupMeta{}).Where("external_id = ?", op.externalID).Pluck("id", &id).Error
+	return id, err
+}
+
+type GetOrgNodeIDByExternalIDOperation struct {
+	repo       *MembershipRepository
+	externalID string
+	tx         *gorm.DB
+}
+
+func (r *MembershipRepository) GetOrgNodeIDByExternalID(externalID string) *GetOrgNodeIDByExternalIDOperation {
+	return &GetOrgNodeIDByExternalIDOperation{
+		repo:       r,
+		externalID: externalID,
+	}
+}
+
+func (op *GetOrgNodeIDByExternalIDOperation) WithTx(tx *gorm.DB) *GetOrgNodeIDByExternalIDOperation {
+	op.tx = tx
+	return op
+}
+
+func (op *GetOrgNodeIDByExternalIDOperation) Exec() (int64, error) {
+	var id int64
+	var err error
+	if op.tx != nil {
+		err = op.tx.Model(&model.OrgNodeMeta{}).Where("external_id = ?", op.externalID).Pluck("id", &id).Error
+	}
+	err = op.repo.db.Model(&model.OrgNodeMeta{}).Where("external_id = ?", op.externalID).Pluck("id", &id).Error
+	return id, err
+}
@@ -0,0 +1,41 @@
+package membership_repo
+
+import (
+	"github.com/XingfenD/yoresee_doc/internal/model"
+	"gorm.io/gorm"
+)
+
+type ListMembershipByTypeAndIDsOperation struct {
+	repo           *MembershipRepository
+	membershipType model.MembershipType
+	membershipIDs  []int64
+	tx             *gorm.DB
+}
+
+func (r *MembershipRepository) ListMembershipByTypeAndIDs(membershipType model.MembershipType, membershipIDs []int64) *ListMembershipByTypeAndIDsOperation {
+	return &ListMembershipByTypeAndIDsOperation{
+		repo:           r,
+		membershipType: membershipType,
+		membershipIDs:  membershipIDs,
+	}
+}
+
+func (op *ListMembershipByTypeAndIDsOperation) WithTx(tx *gorm.DB) *ListMembershipByTypeAndIDsOperation {
+	op.tx = tx
+	return op
+}
+
+func (op *ListMembershipByTypeAndIDsOperation) Exec() ([]model.MembershipRelation, error) {
+	if len(op.membershipIDs) == 0 {
+		return []model.MembershipRelation{}, nil
+	}
+	if op.tx == nil {
+		op.tx = op.repo.db
+	}
+
+	var memberships []model.MembershipRelation
+	err := op.tx.
+		Where("type = ? AND membership_id IN ?", op.membershipType, op.membershipIDs).
+		Find(&memberships).Error
+	return memberships, err
+}
@@ -0,0 +1,35 @@
+package membership_repo
+
+import (
+	"github.com/XingfenD/yoresee_doc/internal/model"
+	"gorm.io/gorm"
+)
+
+type ListUserGroupOperation struct {
+	repo *MembershipRepository
+	tx   *gorm.DB
+}
+
+func (r *MembershipRepository) ListUserGroup() *ListUserGroupOperation {
+	return &ListUserGroupOperation{
+		repo: r,
+	}
+}
+
+func (op *ListUserGroupOperation) WithTx(tx *gorm.DB) *ListUserGroupOperation {
+	op.tx = tx
+	return op
+}
+
+func (op *ListUserGroupOperation) Exec() ([]model.UserGroupMeta, error) {
+	var userGroups []model.UserGroupMeta
+	var err error
+
+	if op.tx != nil {
+		err = op.tx.Find(&userGroups).Error
+	} else {
+		err = op.repo.db.Find(&userGroups).Error
+	}
+
+	return userGroups, err
+}
@@ -0,0 +1,145 @@
+package membership_repo
+
+import (
+	"github.com/XingfenD/yoresee_doc/internal/model"
+	"gorm.io/gorm"
+)
+
+type CreateMembershipOperation struct {
+	repo       *MembershipRepository
+	membership *model.MembershipRelation
+	tx         *gorm.DB
+}
+
+func (r *MembershipRepository) CreateMembership(membership *model.MembershipRelation) *CreateMembershipOperation {
+	return &CreateMembershipOperation{
+		repo:       r,
+		membership: membership,
+	}
+}
+
+func (op *CreateMembershipOperation) WithTx(tx *gorm.DB) *CreateMembershipOperation {
+	op.tx = tx
+	return op
+}
+
+func (op *CreateMembershipOperation) Exec() error {
+	if op.tx != nil {
+		return op.tx.Create(op.membership).Error
+	}
+	return op.repo.db.Create(op.membership).Error
+}
+
+type BatchCreateMembershipOperation struct {
+	repo        *MembershipRepository
+	memberships []*model.MembershipRelation
+	tx          *gorm.DB
+}
+
+func (r *MembershipRepository) BatchCreateMembership(memberships []*model.MembershipRelation) *BatchCreateMembershipOperation {
+	return &BatchCreateMembershipOperation{
+		repo:        r,
+		memberships: memberships,
+	}
+}
+
+func (op *BatchCreateMembershipOperation) WithTx(tx *gorm.DB) *BatchCreateMembershipOperation {
+	op.tx = tx
+	return op
+}
+
+func (op *BatchCreateMembershipOperation) Exec() error {
+	if len(op.memberships) == 0 {
+		return nil
+	}
+
+	if op.tx != nil {
+		return op.tx.Create(&op.memberships).Error
+	}
+	return op.repo.db.Create(&op.memberships).Error
+}
+
+type ListMembershipOperation struct {
+	repo  *MembershipRepository
+	query *model.MembershipRelation
+	tx    *gorm.DB
+}
+
+func (r *MembershipRepository) ListMembership(query *model.MembershipRelation) *ListMembershipOperation {
+	return &ListMembershipOperation{
+		repo:  r,
+		query: query,
+	}
+}
+
+func (op *ListMembershipOperation) WithTx(tx *gorm.DB) *ListMembershipOperation {
+	op.tx = tx
+	return op
+}
+
+func (op *ListMembershipOperation) Exec() ([]model.MembershipRelation, error) {
+	var memberships []model.MembershipRelation
+	var err error
+
+	if op.tx != nil {
+		err = op.tx.Where(op.query).Find(&memberships).Error
+	} else {
+		err = op.repo.db.Where(op.query).Find(&memberships).Error
+	}
+
+	return memberships, err
+}
+
+type DeleteMembershipOperation struct {
+	repo       *MembershipRepository
+	membership *model.MembershipRelation
+	tx         *gorm.DB
+}
+
+func (r *MembershipRepository) DeleteMembership(membership *model.MembershipRelation) *DeleteMembershipOperation {
+	return &DeleteMembershipOperation{
+		repo:       r,
+		membership: membership,
+	}
+}
+
+func (op *DeleteMembershipOperation) WithTx(tx *gorm.DB) *DeleteMembershipOperation {
+	op.tx = tx
+	return op
+}
+
+func (op *DeleteMembershipOperation) Exec() error {
+	if op.tx != nil {
+		return op.tx.Delete(op.membership).Error
+	}
+	return op.repo.db.Delete(op.membership).Error
+}
+
+type BatchDeleteMembershipOperation struct {
+	repo        *MembershipRepository
+	memberships []*model.MembershipRelation
+	tx          *gorm.DB
+}
+
+func (r *MembershipRepository) BatchDeleteMembership(memberships []*model.MembershipRelation) *BatchDeleteMembershipOperation {
+	return &BatchDeleteMembershipOperation{
+		repo:        r,
+		memberships: memberships,
+	}
+}
+
+func (op *BatchDeleteMembershipOperation) WithTx(tx *gorm.DB) *BatchDeleteMembershipOperation {
+	op.tx = tx
+	return op
+}
+
+func (op *BatchDeleteMembershipOperation) Exec() error {
+	if len(op.memberships) == 0 {
+		return nil
+	}
+
+	if op.tx != nil {
+		return op.tx.Delete(&op.memberships).Error
+	}
+	return op.repo.db.Delete(&op.memberships).Error
+}
@@ -0,0 +1,11 @@
+package membership_repo
+
+import "gorm.io/gorm"
+
+type MembershipRepository struct {
+	db *gorm.DB
+}
+
+func NewMembershipRepository(db *gorm.DB) *MembershipRepository {
+	return &MembershipRepository{db: db}
+}
@@ -0,0 +1,172 @@
+package membership_repo
+
+import (
+	"strings"
+
+	"github.com/XingfenD/yoresee_doc/internal/model"
+	"gorm.io/gorm"
+)
+
+type QueryOrgNodeOperation struct {
+	repo     *MembershipRepository
+	tx       *gorm.DB
+	parentID int64
+	keyword  *string
+	page     int
+	pageSize int
+}
+
+func (r *MembershipRepository) QueryOrgNode() *QueryOrgNodeOperation {
+	return &QueryOrgNodeOperation{
+		repo: r,
+	}
+}
+
+func (op *QueryOrgNodeOperation) WithTx(tx *gorm.DB) *QueryOrgNodeOperation {
+	op.tx = tx
+	return op
+}
+
+func (op *QueryOrgNodeOperation) WithParentID(parentID int64) *QueryOrgNodeOperation {
+	op.parentID = parentID
+	return op
+}
+
+func (op *QueryOrgNodeOperation) WithKeyword(keyword *string) *QueryOrgNodeOperation {
+	op.keyword = keyword
+	return op
+}
+
+func (op *QueryOrgNodeOperation) WithPagination(page, pageSize int) *QueryOrgNodeOperation {
+	op.page = page
+	op.pageSize = pageSize
+	return op
+}
+
+func (op *QueryOrgNodeOperation) ExecWithTotal() ([]model.OrgNodeMeta, int64, error) {
+	if op.tx == nil {
+		op.tx = op.repo.db
+	}
+
+	query := op.tx.Model(&model.OrgNodeMeta{})
+	if op.parentID >= 0 {
+		query = query.Where("parent_id = ?", op.parentID)
+	}
+	if op.keyword != nil {
+		trimmed := strings.TrimSpace(*op.keyword)
+		if trimmed != "" {
+			like := "%" + trimmed + "%"
+			query = query.Where("name ILIKE ? OR description ILIKE ?", like, like)
+		}
+	}
+
+	var total int64
+	if err := query.Count(&total).Error; err != nil {
+		return nil, 0, err
+	}
+
+	if op.page > 0 && op.pageSize > 0 {
+		offset := (op.page - 1) * op.pageSize
+		query = query.Offset(offset).Limit(op.pageSize)
+	}
+
+	var orgNodes []model.OrgNodeMeta
+	if err := query.Order("id DESC").Find(&orgNodes).Error; err != nil {
+		return nil, 0, err
+	}
+	return orgNodes, total, nil
+}
+
+func (op *QueryOrgNodeOperation) Exec() ([]model.OrgNodeMeta, error) {
+	if op.tx == nil {
+		op.tx = op.repo.db
+	}
+
+	query := op.tx.Model(&model.OrgNodeMeta{})
+	if op.parentID >= 0 {
+		query = query.Where("parent_id = ?", op.parentID)
+	}
+	if op.keyword != nil {
+		trimmed := strings.TrimSpace(*op.keyword)
+		if trimmed != "" {
+			like := "%" + trimmed + "%"
+			query = query.Where("name ILIKE ? OR description ILIKE ?", like, like)
+		}
+	}
+
+	var orgNodes []model.OrgNodeMeta
+	if err := query.Order("id DESC").Find(&orgNodes).Error; err != nil {
+		return nil, err
+	}
+	return orgNodes, nil
+}
+
+type MGetOrgNodeByIDOperation struct {
+	repo    *MembershipRepository
+	nodeIDs []int64
+	tx      *gorm.DB
+}
+
+func (r *MembershipRepository) MGetOrgNodeByID(nodeIDs []int64) *MGetOrgNodeByIDOperation {
+	return &MGetOrgNodeByIDOperation{
+		repo:    r,
+		nodeIDs: nodeIDs,
+	}
+}
+
+func (op *MGetOrgNodeByIDOperation) WithTx(tx *gorm.DB) *MGetOrgNodeByIDOperation {
+	op.tx = tx
+	return op
+}
+
+func (op *MGetOrgNodeByIDOperation) Exec() (map[int64]*model.OrgNodeMeta, error) {
+	if op.tx == nil {
+		op.tx = op.repo.db
+	}
+
+	var orgNodes []model.OrgNodeMeta
+	if err := op.tx.Where("id IN ?", op.nodeIDs).Find(&orgNodes).Error; err != nil {
+		return nil, err
+	}
+
+	result := make(map[int64]*model.OrgNodeMeta, len(orgNodes))
+	for i := range orgNodes {
+		result[orgNodes[i].ID] = &orgNodes[i]
+	}
+	return result, nil
+}
+
+type QueryOrgNodeByPathPrefixOperation struct {
+	repo   *MembershipRepository
+	tx     *gorm.DB
+	prefix string
+}
+
+func (r *MembershipRepository) QueryOrgNodeByPathPrefix(prefix string) *QueryOrgNodeByPathPrefixOperation {
+	return &QueryOrgNodeByPathPrefixOperation{
+		repo:   r,
+		prefix: prefix,
+	}
+}
+
+func (op *QueryOrgNodeByPathPrefixOperation) WithTx(tx *gorm.DB) *QueryOrgNodeByPathPrefixOperation {
+	op.tx = tx
+	return op
+}
+
+func (op *QueryOrgNodeByPathPrefixOperation) Exec() ([]model.OrgNodeMeta, error) {
+	if op.tx == nil {
+		op.tx = op.repo.db
+	}
+
+	var orgNodes []model.OrgNodeMeta
+	prefix := strings.TrimSpace(op.prefix)
+	if prefix == "" {
+		return []model.OrgNodeMeta{}, nil
+	}
+	like := prefix + ".%"
+	if err := op.tx.Where("path = ? OR path LIKE ?", prefix, like).Find(&orgNodes).Error; err != nil {
+		return nil, err
+	}
+	return orgNodes, nil
+}
@@ -0,0 +1,69 @@
+package membership_repo
+
+import (
+	"strings"
+
+	"github.com/XingfenD/yoresee_doc/internal/model"
+	"gorm.io/gorm"
+)
+
+type QueryUserGroupOperation struct {
+	repo     *MembershipRepository
+	tx       *gorm.DB
+	keyword  *string
+	page     int
+	pageSize int
+}
+
+func (r *MembershipRepository) QueryUserGroup() *QueryUserGroupOperation {
+	return &QueryUserGroupOperation{
+		repo: r,
+	}
+}
+
+func (op *QueryUserGroupOperation) WithTx(tx *gorm.DB) *QueryUserGroupOperation {
+	op.tx = tx
+	return op
+}
+
+func (op *QueryUserGroupOperation) WithKeyword(keyword *string) *QueryUserGroupOperation {
+	op.keyword = keyword
+	return op
+}
+
+func (op *QueryUserGroupOperation) WithPagination(page, pageSize int) *QueryUserGroupOperation {
+	op.page = page
+	op.pageSize = pageSize
+	return op
+}
+
+func (op *QueryUserGroupOperation) ExecWithTotal() ([]model.UserGroupMeta, int64, error) {
+	if op.tx == nil {
+		op.tx = op.repo.db
+	}
+
+	query := op.tx.Model(&model.UserGroupMeta{})
+	if op.keyword != nil {
+		trimmed := strings.TrimSpace(*op.keyword)
+		if trimmed != "" {
+			like := "%" + trimmed + "%"
+			query = query.Where("name ILIKE ? OR description ILIKE ?", like, like)
+		}
+	}
+
+	var total int64
+	if err := query.Count(&total).Error; err != nil {
+		return nil, 0, err
+	}
+
+	if op.page > 0 && op.pageSize > 0 {
+		offset := (op.page - 1) * op.pageSize
+		query = query.Offset(offset).Limit(op.pageSize)
+	}
+
+	var userGroups []model.UserGroupMeta
+	if err := query.Order("id DESC").Find(&userGroups).Error; err != nil {
+		return nil, 0, err
+	}
+	return userGroups, total, nil
+}
@@ -0,0 +1,56 @@
+package membership_repo
+
+import (
+	"github.com/XingfenD/yoresee_doc/internal/model"
+	"gorm.io/gorm"
+)
+
+type UpdateUserGroupOperation struct {
+	repo  *MembershipRepository
+	group *model.UserGroupMeta
+	tx    *gorm.DB
+}
+
+func (r *MembershipRepository) UpdateUserGroup(group *model.UserGroupMeta) *UpdateUserGroupOperation {
+	return &UpdateUserGroupOperation{
+		repo:  r,
+		group: group,
+	}
+}
+
+func (op *UpdateUserGroupOperation) WithTx(tx *gorm.DB) *UpdateUserGroupOperation {
+	op.tx = tx
+	return op
+}
+
+func (op *UpdateUserGroupOperation) Exec() error {
+	if op.tx != nil {
+		return op.tx.Save(op.group).Error
+	}
+	return op.repo.db.Save(op.group).Error
+}
+
+type UpdateOrgNodeOperation struct {
+	repo    *MembershipRepository
+	orgNode *model.OrgNodeMeta
+	tx      *gorm.DB
+}
+
+func (r *MembershipRepository) UpdateOrgNode(orgNode *model.OrgNodeMeta) *UpdateOrgNodeOperation {
+	return &UpdateOrgNodeOperation{
+		repo:    r,
+		orgNode: orgNode,
+	}
+}
+
+func (op *UpdateOrgNodeOperation) WithTx(tx *gorm.DB) *UpdateOrgNodeOperation {
+	op.tx = tx
+	return op
+}
+
+func (op *UpdateOrgNodeOperation) Exec() error {
+	if op.tx != nil {
+		return op.tx.Save(op.orgNode).Error
+	}
+	return op.repo.db.Save(op.orgNode).Error
+}