4158773849
- Introduced a new API for organization management, including creation, updating, and deletion of organizations. - Implemented organization sharing functionality for knowledge bases, allowing users to share knowledge bases with specific organizations and set permissions. - Added UI components for organization selection and sharing dialogs. - Enhanced existing components to support organization-related features, including shared knowledge base handling and organization role management. This update enhances collaboration capabilities within the application by allowing users to manage and share knowledge bases across different organizations.
286 lines
9.6 KiB
Go
286 lines
9.6 KiB
Go
package repository
|
|
|
|
import (
|
|
"context"
|
|
"errors"
|
|
"time"
|
|
|
|
"github.com/Tencent/WeKnora/internal/types"
|
|
"github.com/Tencent/WeKnora/internal/types/interfaces"
|
|
"gorm.io/gorm"
|
|
)
|
|
|
|
var (
|
|
ErrOrganizationNotFound = errors.New("organization not found")
|
|
ErrOrgMemberNotFound = errors.New("organization member not found")
|
|
ErrOrgMemberAlreadyExists = errors.New("member already exists in organization")
|
|
ErrInviteCodeNotFound = errors.New("invite code not found")
|
|
ErrInviteCodeExpired = errors.New("invite code has expired")
|
|
)
|
|
|
|
// organizationRepository implements OrganizationRepository interface
|
|
type organizationRepository struct {
|
|
db *gorm.DB
|
|
}
|
|
|
|
// NewOrganizationRepository creates a new organization repository
|
|
func NewOrganizationRepository(db *gorm.DB) interfaces.OrganizationRepository {
|
|
return &organizationRepository{db: db}
|
|
}
|
|
|
|
// Create creates a new organization
|
|
func (r *organizationRepository) Create(ctx context.Context, org *types.Organization) error {
|
|
return r.db.WithContext(ctx).Create(org).Error
|
|
}
|
|
|
|
// GetByID gets an organization by ID
|
|
func (r *organizationRepository) GetByID(ctx context.Context, id string) (*types.Organization, error) {
|
|
var org types.Organization
|
|
if err := r.db.WithContext(ctx).Where("id = ?", id).First(&org).Error; err != nil {
|
|
if errors.Is(err, gorm.ErrRecordNotFound) {
|
|
return nil, ErrOrganizationNotFound
|
|
}
|
|
return nil, err
|
|
}
|
|
return &org, nil
|
|
}
|
|
|
|
// GetByInviteCode gets an organization by invite code (returns ErrInviteCodeExpired if code has expired)
|
|
func (r *organizationRepository) GetByInviteCode(ctx context.Context, inviteCode string) (*types.Organization, error) {
|
|
var org types.Organization
|
|
if err := r.db.WithContext(ctx).Where("invite_code = ?", inviteCode).First(&org).Error; err != nil {
|
|
if errors.Is(err, gorm.ErrRecordNotFound) {
|
|
return nil, ErrInviteCodeNotFound
|
|
}
|
|
return nil, err
|
|
}
|
|
if org.InviteCodeExpiresAt != nil && org.InviteCodeExpiresAt.Before(time.Now()) {
|
|
return nil, ErrInviteCodeExpired
|
|
}
|
|
return &org, nil
|
|
}
|
|
|
|
// ListByUserID lists organizations that a user belongs to
|
|
func (r *organizationRepository) ListByUserID(ctx context.Context, userID string) ([]*types.Organization, error) {
|
|
var orgs []*types.Organization
|
|
|
|
// Get organizations where user is a member
|
|
err := r.db.WithContext(ctx).
|
|
Joins("JOIN organization_members ON organization_members.organization_id = organizations.id").
|
|
Where("organization_members.user_id = ?", userID).
|
|
Order("organizations.created_at DESC").
|
|
Find(&orgs).Error
|
|
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return orgs, nil
|
|
}
|
|
|
|
// Update updates an organization (Select ensures zero values like invite_code_validity_days=0 are persisted)
|
|
func (r *organizationRepository) Update(ctx context.Context, org *types.Organization) error {
|
|
return r.db.WithContext(ctx).Model(&types.Organization{}).Where("id = ?", org.ID).
|
|
Select("name", "description", "require_approval", "invite_code_validity_days", "updated_at").
|
|
Updates(org).Error
|
|
}
|
|
|
|
// Delete soft deletes an organization
|
|
func (r *organizationRepository) Delete(ctx context.Context, id string) error {
|
|
return r.db.WithContext(ctx).Where("id = ?", id).Delete(&types.Organization{}).Error
|
|
}
|
|
|
|
// AddMember adds a member to an organization
|
|
func (r *organizationRepository) AddMember(ctx context.Context, member *types.OrganizationMember) error {
|
|
// Check if member already exists
|
|
var count int64
|
|
r.db.WithContext(ctx).Model(&types.OrganizationMember{}).
|
|
Where("organization_id = ? AND user_id = ?", member.OrganizationID, member.UserID).
|
|
Count(&count)
|
|
|
|
if count > 0 {
|
|
return ErrOrgMemberAlreadyExists
|
|
}
|
|
|
|
return r.db.WithContext(ctx).Create(member).Error
|
|
}
|
|
|
|
// RemoveMember removes a member from an organization
|
|
func (r *organizationRepository) RemoveMember(ctx context.Context, orgID string, userID string) error {
|
|
result := r.db.WithContext(ctx).
|
|
Where("organization_id = ? AND user_id = ?", orgID, userID).
|
|
Delete(&types.OrganizationMember{})
|
|
|
|
if result.Error != nil {
|
|
return result.Error
|
|
}
|
|
if result.RowsAffected == 0 {
|
|
return ErrOrgMemberNotFound
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// UpdateMemberRole updates a member's role in an organization
|
|
func (r *organizationRepository) UpdateMemberRole(ctx context.Context, orgID string, userID string, role types.OrgMemberRole) error {
|
|
result := r.db.WithContext(ctx).
|
|
Model(&types.OrganizationMember{}).
|
|
Where("organization_id = ? AND user_id = ?", orgID, userID).
|
|
Update("role", role)
|
|
|
|
if result.Error != nil {
|
|
return result.Error
|
|
}
|
|
if result.RowsAffected == 0 {
|
|
return ErrOrgMemberNotFound
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// ListMembers lists all members of an organization
|
|
func (r *organizationRepository) ListMembers(ctx context.Context, orgID string) ([]*types.OrganizationMember, error) {
|
|
var members []*types.OrganizationMember
|
|
err := r.db.WithContext(ctx).
|
|
Preload("User").
|
|
Where("organization_id = ?", orgID).
|
|
Order("created_at ASC").
|
|
Find(&members).Error
|
|
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return members, nil
|
|
}
|
|
|
|
// GetMember gets a specific member of an organization
|
|
func (r *organizationRepository) GetMember(ctx context.Context, orgID string, userID string) (*types.OrganizationMember, error) {
|
|
var member types.OrganizationMember
|
|
err := r.db.WithContext(ctx).
|
|
Where("organization_id = ? AND user_id = ?", orgID, userID).
|
|
First(&member).Error
|
|
|
|
if err != nil {
|
|
if errors.Is(err, gorm.ErrRecordNotFound) {
|
|
return nil, ErrOrgMemberNotFound
|
|
}
|
|
return nil, err
|
|
}
|
|
return &member, nil
|
|
}
|
|
|
|
// CountMembers counts the number of members in an organization
|
|
func (r *organizationRepository) CountMembers(ctx context.Context, orgID string) (int64, error) {
|
|
var count int64
|
|
err := r.db.WithContext(ctx).
|
|
Model(&types.OrganizationMember{}).
|
|
Where("organization_id = ?", orgID).
|
|
Count(&count).Error
|
|
return count, err
|
|
}
|
|
|
|
// UpdateInviteCode updates the invite code and optional expiry for an organization (expiresAt nil = never expire)
|
|
func (r *organizationRepository) UpdateInviteCode(ctx context.Context, orgID string, inviteCode string, expiresAt *time.Time) error {
|
|
updates := map[string]interface{}{"invite_code": inviteCode, "invite_code_expires_at": expiresAt}
|
|
return r.db.WithContext(ctx).
|
|
Model(&types.Organization{}).
|
|
Where("id = ?", orgID).
|
|
Updates(updates).Error
|
|
}
|
|
|
|
// ----------------
|
|
// Join Requests
|
|
// ----------------
|
|
|
|
var ErrJoinRequestNotFound = errors.New("join request not found")
|
|
|
|
// CreateJoinRequest creates a new join request
|
|
func (r *organizationRepository) CreateJoinRequest(ctx context.Context, request *types.OrganizationJoinRequest) error {
|
|
return r.db.WithContext(ctx).Create(request).Error
|
|
}
|
|
|
|
// GetJoinRequestByID gets a join request by ID
|
|
func (r *organizationRepository) GetJoinRequestByID(ctx context.Context, id string) (*types.OrganizationJoinRequest, error) {
|
|
var request types.OrganizationJoinRequest
|
|
err := r.db.WithContext(ctx).
|
|
Preload("User").
|
|
Where("id = ?", id).
|
|
First(&request).Error
|
|
if err != nil {
|
|
if errors.Is(err, gorm.ErrRecordNotFound) {
|
|
return nil, ErrJoinRequestNotFound
|
|
}
|
|
return nil, err
|
|
}
|
|
return &request, nil
|
|
}
|
|
|
|
// GetPendingJoinRequest gets a pending join request for a user in an organization (any type)
|
|
func (r *organizationRepository) GetPendingJoinRequest(ctx context.Context, orgID string, userID string) (*types.OrganizationJoinRequest, error) {
|
|
var request types.OrganizationJoinRequest
|
|
err := r.db.WithContext(ctx).
|
|
Where("organization_id = ? AND user_id = ? AND status = ?", orgID, userID, types.JoinRequestStatusPending).
|
|
First(&request).Error
|
|
if err != nil {
|
|
if errors.Is(err, gorm.ErrRecordNotFound) {
|
|
return nil, ErrJoinRequestNotFound
|
|
}
|
|
return nil, err
|
|
}
|
|
return &request, nil
|
|
}
|
|
|
|
// GetPendingRequestByType gets a pending request for a user filtered by request type
|
|
func (r *organizationRepository) GetPendingRequestByType(ctx context.Context, orgID string, userID string, requestType types.JoinRequestType) (*types.OrganizationJoinRequest, error) {
|
|
var request types.OrganizationJoinRequest
|
|
err := r.db.WithContext(ctx).
|
|
Where("organization_id = ? AND user_id = ? AND status = ? AND request_type = ?", orgID, userID, types.JoinRequestStatusPending, requestType).
|
|
First(&request).Error
|
|
if err != nil {
|
|
if errors.Is(err, gorm.ErrRecordNotFound) {
|
|
return nil, ErrJoinRequestNotFound
|
|
}
|
|
return nil, err
|
|
}
|
|
return &request, nil
|
|
}
|
|
|
|
// ListJoinRequests lists join requests for an organization
|
|
func (r *organizationRepository) ListJoinRequests(ctx context.Context, orgID string, status types.JoinRequestStatus) ([]*types.OrganizationJoinRequest, error) {
|
|
var requests []*types.OrganizationJoinRequest
|
|
query := r.db.WithContext(ctx).
|
|
Preload("User").
|
|
Where("organization_id = ?", orgID)
|
|
|
|
if status != "" {
|
|
query = query.Where("status = ?", status)
|
|
}
|
|
|
|
err := query.Order("created_at DESC").Find(&requests).Error
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return requests, nil
|
|
}
|
|
|
|
// CountJoinRequests counts join requests for an organization by status
|
|
func (r *organizationRepository) CountJoinRequests(ctx context.Context, orgID string, status types.JoinRequestStatus) (int64, error) {
|
|
var count int64
|
|
query := r.db.WithContext(ctx).Model(&types.OrganizationJoinRequest{}).Where("organization_id = ?", orgID)
|
|
if status != "" {
|
|
query = query.Where("status = ?", status)
|
|
}
|
|
err := query.Count(&count).Error
|
|
return count, err
|
|
}
|
|
|
|
// UpdateJoinRequestStatus updates the status of a join request
|
|
func (r *organizationRepository) UpdateJoinRequestStatus(ctx context.Context, id string, status types.JoinRequestStatus, reviewedBy string, reviewMessage string) error {
|
|
return r.db.WithContext(ctx).
|
|
Model(&types.OrganizationJoinRequest{}).
|
|
Where("id = ?", id).
|
|
Updates(map[string]interface{}{
|
|
"status": status,
|
|
"reviewed_by": reviewedBy,
|
|
"reviewed_at": gorm.Expr("NOW()"),
|
|
"review_message": reviewMessage,
|
|
}).Error
|
|
}
|