617 lines
16 KiB
Go
617 lines
16 KiB
Go
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
|
|
}
|