package services import ( "errors" "math" "sort" "strings" "sync" "time" "server/models" ) const DefaultTenantUserQuota = 20 const DefaultPackageDurationDays = 365 const DefaultTenantExtraUserPrice = 200.00 var ErrTenantQuotaExceeded = errors.New("tenant user quota exceeded") func CountTenantUsers(tid uint64) (int, error) { if tid == 0 { return 0, nil } cnt, err := models.Orm.QueryTable(new(models.SystemTenantUser)). Filter("tid", tid). Filter("delete_time__isnull", true). Count() return int(cnt), err } func PackageDurationDays(pkg *models.SystemTenantPackage) int { if pkg == nil || pkg.DurationDays <= 0 { return DefaultPackageDurationDays } return pkg.DurationDays } func PackageExpireFromNow(pkg *models.SystemTenantPackage) time.Time { return time.Now().AddDate(0, 0, PackageDurationDays(pkg)) } func tenantPackageExpired(tenant *models.SystemTenant) bool { return tenant.PackageExpireTime != nil && tenant.PackageExpireTime.Before(time.Now()) } func GetTenantPackage(tid uint64) (*models.SystemTenantPackage, error) { if tid == 0 { return nil, errors.New("tid 不能为空") } var tenant models.SystemTenant if err := models.Orm.QueryTable(new(models.SystemTenant)).Filter("id", tid).One(&tenant); err != nil { return nil, err } if tenant.PackageID > 0 { if tenantPackageExpired(&tenant) { return downgradeExpiredTenantPackage(tid) } var pkg models.SystemTenantPackage if err := models.Orm.QueryTable(new(models.SystemTenantPackage)). Filter("id", tenant.PackageID). Filter("delete_time__isnull", true). One(&pkg); err == nil { return &pkg, nil } } return GetDefaultTenantPackage() } func GetBasicTenantPackage() (*models.SystemTenantPackage, error) { var pkg models.SystemTenantPackage err := models.Orm.QueryTable(new(models.SystemTenantPackage)). Filter("code", "basic"). Filter("delete_time__isnull", true). Filter("status", 1). One(&pkg) if err == nil { return &pkg, nil } return GetDefaultTenantPackage() } func downgradeExpiredTenantPackage(tid uint64) (*models.SystemTenantPackage, error) { basic, err := GetBasicTenantPackage() if err != nil { return nil, err } _, _ = models.Orm.QueryTable(new(models.SystemTenant)). Filter("id", tid). Update(map[string]interface{}{ "package_id": basic.ID, "package_expire_time": nil, }) return basic, nil } func GetDefaultTenantPackage() (*models.SystemTenantPackage, error) { var pkg models.SystemTenantPackage err := models.Orm.QueryTable(new(models.SystemTenantPackage)). Filter("delete_time__isnull", true). Filter("status", 1). Filter("is_default", 1). OrderBy("sort", "id"). One(&pkg) if err == nil { return &pkg, nil } var fallback models.SystemTenantPackage if err2 := models.Orm.QueryTable(new(models.SystemTenantPackage)). Filter("delete_time__isnull", true). Filter("status", 1). OrderBy("sort", "id"). One(&fallback); err2 != nil { return nil, err2 } return &fallback, nil } func GetTenantPackageModules(tid uint64) ([]models.SystemTenantPackageModule, error) { pkg, err := GetTenantPackage(tid) if err != nil { return nil, err } var rows []models.SystemTenantPackageModule _, err = models.Orm.QueryTable(new(models.SystemTenantPackageModule)). Filter("package_id", pkg.ID). OrderBy("id"). All(&rows) return rows, err } func NormalizeModuleCode(code string) string { return strings.ToLower(strings.TrimSpace(code)) } const moduleCodesCacheTTL = 60 * time.Second type tenantModuleCodesItem struct { codes map[string]bool expireAt time.Time } var ( tenantModuleCodesMu sync.RWMutex tenantModuleCodesCache = map[uint64]tenantModuleCodesItem{} ) func GetTenantModuleCodesCached(tid uint64) map[string]bool { now := time.Now() tenantModuleCodesMu.RLock() item, ok := tenantModuleCodesCache[tid] tenantModuleCodesMu.RUnlock() if ok && now.Before(item.expireAt) { return item.codes } codes := GetTenantModuleCodes(tid) tenantModuleCodesMu.Lock() if len(tenantModuleCodesCache) > 5000 { for k, v := range tenantModuleCodesCache { if now.After(v.expireAt) { delete(tenantModuleCodesCache, k) } } } tenantModuleCodesCache[tid] = tenantModuleCodesItem{codes: codes, expireAt: now.Add(moduleCodesCacheTTL)} tenantModuleCodesMu.Unlock() return codes } func InvalidateTenantModuleCodes(tid uint64) { if tid == 0 { return } tenantModuleCodesMu.Lock() delete(tenantModuleCodesCache, tid) tenantModuleCodesMu.Unlock() } func IsModuleEnabled(tid uint64, moduleCode string) bool { code := NormalizeModuleCode(moduleCode) if code == "" || tid == 0 { return true } codes := GetTenantModuleCodesCached(tid) if len(codes) == 0 { return true } return codes[code] } func DayStart(t time.Time) time.Time { return time.Date(t.Year(), t.Month(), t.Day(), 0, 0, 0, 0, t.Location()) } func ProductOrderExpireAt(order *models.PlatformProductOrder) *time.Time { if order == nil { return nil } if order.ExpireTime != nil { t := DayStart(*order.ExpireTime) return &t } if order.ActivateTime != nil { t := DayStart(*order.ActivateTime).AddDate(0, 0, models.ProductOrderDurationDays) return &t } return nil } func ProductOrderExpired(order *models.PlatformProductOrder, now time.Time) bool { expire := ProductOrderExpireAt(order) return expire != nil && !now.Before(*expire) } func GetTenantModuleCodes(tid uint64) map[string]bool { codes := map[string]bool{} mark := func(code string) { if c := NormalizeModuleCode(code); c != "" { codes[c] = true } } rows, err := GetTenantPackageModules(tid) if err == nil { for _, r := range rows { mark(r.ModuleCode) } } if tid == 0 { return codes } var orders []models.PlatformProductOrder if _, err := models.Orm.QueryTable(new(models.PlatformProductOrder)). Filter("tid", tid). Filter("status", models.ProductOrderStatusActivated). Filter("product_id__gt", 0). Filter("delete_time__isnull", true). All(&orders); err != nil || len(orders) == 0 { return codes } now := time.Now() validOrders := make([]models.PlatformProductOrder, 0, len(orders)) for _, order := range orders { if ProductOrderExpired(&order, now) { continue } validOrders = append(validOrders, order) } if len(validOrders) == 0 { return codes } productIDs := make([]uint64, 0, len(validOrders)) for _, order := range validOrders { productIDs = append(productIDs, order.ProductID) } var products []models.PlatformProduct if _, err := models.Orm.QueryTable(new(models.PlatformProduct)). Filter("id__in", productIDs). All(&products); err != nil { return codes } for _, product := range products { code := product.ModuleCode if strings.TrimSpace(code) == "" { code = product.Code } mark(code) } return codes } type TenantQuotaCheck struct { Quota int `json:"quota"` Used int `json:"used"` Allowed bool `json:"allowed"` } func CheckTenantUserQuota(tid, uid uint64) (*TenantQuotaCheck, error) { result := &TenantQuotaCheck{Quota: DefaultTenantUserQuota, Allowed: true} if tid == 0 { return result, nil } quota := DefaultTenantUserQuota var tenant models.SystemTenant if err := models.Orm.QueryTable(new(models.SystemTenant)).Filter("id", tid).One(&tenant); err == nil && tenant.UserQuota > 0 { quota = tenant.UserQuota } result.Quota = quota if uid > 0 { exist, err := models.Orm.QueryTable(new(models.SystemTenantUser)). Filter("tid", tid). Filter("uid", ResolveTenantUID(tid, uid)). Filter("delete_time__isnull", true). Count() if err == nil && exist > 0 { result.Allowed = true return result, nil } } used, err := CountTenantUsers(tid) if err != nil { return nil, err } result.Used = used result.Allowed = used < quota return result, nil } func EnsureTenantUserQuota(tid, uid uint64) error { check, err := CheckTenantUserQuota(tid, uid) if err != nil { return err } if !check.Allowed { return ErrTenantQuotaExceeded } return nil } type TenantQuotaInfo struct { Tid uint64 `json:"tid"` PackageID uint64 `json:"package_id"` PackageName string `json:"package_name"` Quota int `json:"quota"` Used int `json:"used"` Remaining int `json:"remaining"` ExtraUserPrice float64 `json:"extra_user_price"` EffectivePackageID uint64 `json:"effective_package_id"` DurationDays int `json:"duration_days"` PackageExpireTime *time.Time `json:"package_expire_time"` DaysRemaining int `json:"days_remaining"` } func GetTenantQuotaInfo(tid uint64) (*TenantQuotaInfo, error) { info := &TenantQuotaInfo{Tid: tid, Quota: DefaultTenantUserQuota, ExtraUserPrice: DefaultTenantExtraUserPrice} var tenant models.SystemTenant if err := models.Orm.QueryTable(new(models.SystemTenant)).Filter("id", tid).One(&tenant); err != nil { return nil, err } if tenant.UserQuota > 0 { info.Quota = tenant.UserQuota } used, err := CountTenantUsers(tid) if err != nil { return nil, err } info.Used = used info.Remaining = info.Quota - used if info.Remaining < 0 { info.Remaining = 0 } if pkg, err := GetTenantPackage(tid); err == nil && pkg != nil { info.EffectivePackageID = pkg.ID info.PackageName = pkg.Name info.DurationDays = PackageDurationDays(pkg) if pkg.ExtraUserPrice > 0 { info.ExtraUserPrice = pkg.ExtraUserPrice } } var fresh models.SystemTenant if e := models.Orm.QueryTable(new(models.SystemTenant)).Filter("id", tid).One(&fresh); e == nil { tenant = fresh } info.PackageID = tenant.PackageID info.PackageExpireTime = tenant.PackageExpireTime if tenant.PackageExpireTime != nil { remain := int(math.Ceil(time.Until(*tenant.PackageExpireTime).Hours() / 24)) if remain < 0 { remain = 0 } info.DaysRemaining = remain } return info, nil } func IncreaseTenantQuota(tid uint64, count int) (int, int, error) { if tid == 0 || count <= 0 { return 0, 0, errors.New("参数错误") } var tenant models.SystemTenant if err := models.Orm.QueryTable(new(models.SystemTenant)).Filter("id", tid).One(&tenant); err != nil { return 0, 0, errors.New("租户不存在") } before := tenant.UserQuota if before <= 0 { before = DefaultTenantUserQuota } after := before + count _, err := models.Orm.QueryTable(new(models.SystemTenant)). Filter("id", tid). Update(map[string]interface{}{"user_quota": after}) if err != nil { return before, after, err } return before, after, nil } func ApplyPackageToTenant(tid, packageID uint64, syncQuota bool) (int, error) { if tid == 0 || packageID == 0 { return 0, errors.New("参数错误") } var pkg models.SystemTenantPackage if err := models.Orm.QueryTable(new(models.SystemTenantPackage)). Filter("id", packageID). Filter("delete_time__isnull", true). One(&pkg); err != nil { return 0, errors.New("套餐不存在") } var tenant models.SystemTenant if err := models.Orm.QueryTable(new(models.SystemTenant)).Filter("id", tid).One(&tenant); err != nil { return 0, errors.New("租户不存在") } update := map[string]interface{}{"package_id": packageID} newQuota := tenant.UserQuota if syncQuota { current := tenant.UserQuota if current <= 0 { current = DefaultTenantUserQuota } newQuota = pkg.UserQuota if newQuota <= 0 { newQuota = DefaultTenantUserQuota } if newQuota < current { newQuota = current } update["user_quota"] = newQuota } base := time.Now() if tenant.PackageID == packageID && tenant.PackageExpireTime != nil && tenant.PackageExpireTime.After(base) { base = *tenant.PackageExpireTime } update["package_expire_time"] = base.AddDate(0, 0, PackageDurationDays(&pkg)) if _, err := models.Orm.QueryTable(new(models.SystemTenant)). Filter("id", tid). Update(update); err != nil { return 0, err } InvalidateTenantModuleCodes(tid) return newQuota, nil } func sortModulesByPathDesc(modules []models.SystemModules) []models.SystemModules { list := make([]models.SystemModules, 0, len(modules)) for _, m := range modules { if strings.TrimSpace(m.Path) != "" { list = append(list, m) } } sort.SliceStable(list, func(i, j int) bool { return len(list[i].Path) > len(list[j].Path) }) return list } func ownerModuleCode(sortedModules []models.SystemModules, path string) (string, bool) { p := strings.TrimSuffix(strings.TrimSpace(path), "/") if p == "" { return "", false } for _, m := range sortedModules { mp := strings.TrimSuffix(strings.TrimSpace(m.Path), "/") if mp == "" { continue } if p == mp || strings.HasPrefix(p, mp+"/") { return m.Code, true } } return "", false } func ModuleCodesOwningMenus(allModules []models.SystemModules, menus []models.SystemMenu) map[string]bool { codes := map[string]bool{} if len(allModules) == 0 || len(menus) == 0 { return codes } sorted := sortModulesByPathDesc(allModules) for _, m := range menus { path := "" if m.Path != nil { path = *m.Path } if code, ok := ownerModuleCode(sorted, path); ok { codes[NormalizeModuleCode(code)] = true } } return codes } func FilterMenusByTenantModules(menus []models.SystemMenu, allModules []models.SystemModules, allowedCodes map[string]bool) []models.SystemMenu { if len(menus) == 0 || len(allModules) == 0 { return menus } sorted := sortModulesByPathDesc(allModules) out := make([]models.SystemMenu, 0, len(menus)) for _, m := range menus { path := "" if m.Path != nil { path = *m.Path } code, ok := ownerModuleCode(sorted, path) if !ok { out = append(out, m) continue } if allowedCodes[NormalizeModuleCode(code)] { out = append(out, m) } } return out } func MarkMenusLockedByTenantModules(menus []models.SystemMenu, allModules []models.SystemModules, allowedCodes map[string]bool) ([]models.SystemMenu, map[uint64]bool) { lockedIDs := map[uint64]bool{} if len(menus) == 0 || len(allModules) == 0 { return menus, lockedIDs } sorted := sortModulesByPathDesc(allModules) kept := make([]models.SystemMenu, 0, len(menus)) for _, m := range menus { path := "" if m.Path != nil { path = *m.Path } code, ok := ownerModuleCode(sorted, path) if ok && !allowedCodes[NormalizeModuleCode(code)] { lockedIDs[m.ID] = true } kept = append(kept, m) } if len(lockedIDs) == 0 { return kept, lockedIDs } childrenOf := map[uint64][]uint64{} for _, m := range kept { if m.Pid > 0 { pid := uint64(m.Pid) childrenOf[pid] = append(childrenOf[pid], m.ID) } } queue := make([]uint64, 0, len(lockedIDs)) for id := range lockedIDs { queue = append(queue, id) } for len(queue) > 0 { id := queue[0] queue = queue[1:] for _, child := range childrenOf[id] { if !lockedIDs[child] { lockedIDs[child] = true queue = append(queue, child) } } } return kept, lockedIDs } const PackagePurchaseURLCode = "package_purchase_url" func GetPackagePurchaseURL() string { var s models.PlatformNormalSetting if err := models.Orm.QueryTable(new(models.PlatformNormalSetting)). Filter("code", PackagePurchaseURLCode). Filter("delete_time__isnull", true). One(&s); err != nil { return "" } return strings.TrimSpace(s.Value) } func SavePackagePurchaseURL(url string) error { url = strings.TrimSpace(url) var s models.PlatformNormalSetting err := models.Orm.QueryTable(new(models.PlatformNormalSetting)). Filter("code", PackagePurchaseURLCode). Filter("delete_time__isnull", true). One(&s) if err != nil { s = models.PlatformNormalSetting{ Name: "套餐购买链接", Code: PackagePurchaseURLCode, Value: url, Remark: "租户端未开通功能卡片「购买」按钮跳转地址", } _, err = models.Orm.Insert(&s) return err } now := time.Now() s.Value = url s.UpdateTime = &now _, err = models.Orm.Update(&s) return err } func ListEnabledModules() ([]models.SystemModules, error) { var rows []models.SystemModules _, err := models.Orm.QueryTable(new(models.SystemModules)). Filter("delete_time__isnull", true). Filter("status", 1). OrderBy("sort", "id"). All(&rows) return rows, err }