wsy182/Cloudreve
1
0
Fork 0
mirror of https://github.com/halejohn/Cloudreve.git synced 2026-01-26 09:34:57 +08:00
Code Issues Packages Projects Releases Wiki Activity

Modify: clean useless codes

Browse Source
This commit is contained in:
HFO4
2020-03-11 15:45:00 +08:00
parent 09de05548f
commit 45b54b3455
28 changed files with 8 additions and 1802 deletions
Download Patch File Download Diff File Expand all files Collapse all files

75
service/admin/order.go
View File

@@ -1,75 +0,0 @@
package admin
import (
model "github.com/HFO4/cloudreve/models"
"github.com/HFO4/cloudreve/pkg/serializer"
"github.com/gin-gonic/gin"
"strings"
)
// OrderBatchService 订单批量操作服务
type OrderBatchService struct {
ID []uint `json:"id" binding:"min=1"`
}
// Delete 删除订单
func (service *OrderBatchService) Delete(c *gin.Context) serializer.Response {
if err := model.DB.Where("id in (?)", service.ID).Delete(&model.Order{}).Error; err != nil {
return serializer.DBErr("无法删除订单", err)
}
return serializer.Response{}
}
// Orders 列出订单
func (service *AdminListService) Orders() serializer.Response {
var res []model.Order
total := 0
tx := model.DB.Model(&model.Order{})
if service.OrderBy != "" {
tx = tx.Order(service.OrderBy)
}
for k, v := range service.Conditions {
tx = tx.Where(k+" = ?", v)
}
if len(service.Searches) > 0 {
search := ""
for k, v := range service.Searches {
search += k + " like '%" + v + "%' OR "
}
search = strings.TrimSuffix(search, " OR ")
tx = tx.Where(search)
}
// 计算总数用于分页
tx.Count(&total)
// 查询记录
tx.Limit(service.PageSize).Offset((service.Page - 1) * service.PageSize).Find(&res)
// 查询对应用户，同时计算HashID
users := make(map[uint]model.User)
for _, file := range res {
users[file.UserID] = model.User{}
}
userIDs := make([]uint, 0, len(users))
for k := range users {
userIDs = append(userIDs, k)
}
var userList []model.User
model.DB.Where("id in (?)", userIDs).Find(&userList)
for _, v := range userList {
users[v.ID] = v
}
return serializer.Response{Data: map[string]interface{}{
"total": total,
"items": res,
"users": users,
}}
}

5
service/admin/policy.go
View File

@@ -71,10 +71,7 @@ func (service *PolicyService) Delete() serializer.Response {
// 检查用户组使用
var groups []model.Group
model.DB.Model(&model.Group{}).Where(
"policies like ? OR policies like ? OR policies like ? OR policies like ?",
fmt.Sprintf("[%d,%%", service.ID),
fmt.Sprintf("%%,%d]", service.ID),
fmt.Sprintf("%%,%d,%%", service.ID),
"policies like ?",
fmt.Sprintf("%%[%d]%%", service.ID),
).Find(&groups)

6
service/admin/user.go
View File

@@ -71,12 +71,6 @@ func (service *UserBatchService) Delete() serializer.Response {
model.DB.Where("user_id = ?", uid).Delete(&model.Download{})
model.DB.Where("user_id = ?", uid).Delete(&model.Task{})
// 删除订单记录
model.DB.Where("user_id = ?", uid).Delete(&model.Order{})
// 删除容量包
model.DB.Where("user_id = ?", uid).Delete(&model.StoragePack{})
// 删除标签
model.DB.Where("user_id = ?", uid).Delete(&model.Tag{})

98
service/admin/vas.go
View File

@@ -1,98 +0,0 @@
package admin
import (
model "github.com/HFO4/cloudreve/models"
"github.com/HFO4/cloudreve/pkg/serializer"
"github.com/gofrs/uuid"
)
// GenerateRedeemsService 兑换码生成服务
type GenerateRedeemsService struct {
Num int `json:"num" binding:"required,min=1,max=100"`
ID int64 `json:"id"`
Time int `json:"time" binding:"required,min=1"`
Type int `json:"type" binding:"min=0,max=2"`
}
// SingleIDService 单ID服务
type SingleIDService struct {
ID uint `uri:"id" binding:"required"`
}
// DeleteRedeem 删除兑换码
func (service *SingleIDService) DeleteRedeem() serializer.Response {
if err := model.DB.Where("id = ?", service.ID).Delete(&model.Redeem{}).Error; err != nil {
return serializer.DBErr("无法删除兑换码", err)
}
return serializer.Response{}
}
// Generate 生成兑换码
func (service *GenerateRedeemsService) Generate() serializer.Response {
res := make([]string, service.Num)
redeem := model.Redeem{}
// 开始事务
tx := model.DB.Begin()
if err := tx.Error; err != nil {
return serializer.DBErr("无法开启事务", err)
}
// 创建每个兑换码
for i := 0; i < service.Num; i++ {
redeem.Model.ID = 0
redeem.Num = service.Time
redeem.Type = service.Type
redeem.ProductID = service.ID
redeem.Used = false
// 生成唯一兑换码
u2, err := uuid.NewV4()
if err != nil {
tx.Rollback()
return serializer.Err(serializer.CodeInternalSetting, "无法生成兑换码", err)
}
redeem.Code = u2.String()
if err := tx.Create(&redeem).Error; err != nil {
tx.Rollback()
return serializer.DBErr("无法创建兑换码记录", err)
}
res[i] = redeem.Code
}
if err := tx.Commit().Error; err != nil {
return serializer.DBErr("无法创建兑换码记录", err)
}
return serializer.Response{Data: res}
}
// Redeems 列出激活码
func (service *AdminListService) Redeems() serializer.Response {
var res []model.Redeem
total := 0
tx := model.DB.Model(&model.Redeem{})
if service.OrderBy != "" {
tx = tx.Order(service.OrderBy)
}
for k, v := range service.Conditions {
tx = tx.Where("? = ?", k, v)
}
// 计算总数用于分页
tx.Count(&total)
// 查询记录
tx.Limit(service.PageSize).Offset((service.Page - 1) * service.PageSize).Find(&res)
return serializer.Response{Data: map[string]interface{}{
"total": total,
"items": res,
}}
}

55
service/setting/webdav.go
View File

@@ -2,8 +2,6 @@ package setting
import (
model "github.com/HFO4/cloudreve/models"
"github.com/HFO4/cloudreve/pkg/filesystem"
"github.com/HFO4/cloudreve/pkg/hashid"
"github.com/HFO4/cloudreve/pkg/serializer"
"github.com/HFO4/cloudreve/pkg/util"
"github.com/gin-gonic/gin"
@@ -30,59 +28,6 @@ type WebDAVMountCreateService struct {
Policy string `json:"policy" binding:"required,min=1"`
}
// Create 创建目录挂载
func (service *WebDAVMountCreateService) Create(c *gin.Context, user *model.User) serializer.Response {
// 创建文件系统
fs, err := filesystem.NewFileSystem(user)
if err != nil {
return serializer.Err(serializer.CodePolicyNotAllowed, err.Error(), err)
}
defer fs.Recycle()
// 检索要挂载的目录
exist, folder := fs.IsPathExist(service.Path)
if !exist {
return serializer.Err(serializer.CodeNotFound, "路径不存在", err)
}
// 检索要挂载的存储策略
policyID, err := hashid.DecodeHashID(service.Policy, hashid.PolicyID)
if err != nil {
return serializer.Err(serializer.CodeNotFound, "存储策略不存在", err)
}
// 检查存储策略是否可用
if policy, err := model.GetPolicyByID(policyID); err != nil || !util.ContainsUint(user.Group.PolicyList, policy.ID) {
return serializer.Err(serializer.CodeNotFound, "存储策略不可用", err)
}
// 挂载
if err := folder.Mount(policyID); err != nil {
return serializer.Err(serializer.CodeDBError, "挂载失败", err)
}
return serializer.Response{
Data: map[string]interface{}{
"id": hashid.HashID(folder.ID, hashid.FolderID),
},
}
}
// Unmount 取消目录挂载
func (service *WebDAVListService) Unmount(c *gin.Context, user *model.User) serializer.Response {
folderID, _ := c.Get("object_id")
folder, err := model.GetFoldersByIDs([]uint{folderID.(uint)}, user.ID)
if err != nil || len(folder) == 0 {
return serializer.Err(serializer.CodeNotFound, "目录不存在", err)
}
if err := folder[0].Mount(0); err != nil {
return serializer.Err(serializer.CodeDBError, "取消挂载失败", err)
}
return serializer.Response{}
}
// Create 创建WebDAV账户
func (service *WebDAVAccountCreateService) Create(c *gin.Context, user *model.User) serializer.Response {
account := model.Webdav{

33
service/share/visit.go
View File

@@ -223,39 +223,6 @@ func (service *Service) CreateDocPreviewSession(c *gin.Context) serializer.Respo
return subService.CreateDocPreviewSession(ctx, c)
}
// SaveToMyFile 将此分享转存到自己的网盘
func (service *Service) SaveToMyFile(c *gin.Context) serializer.Response {
shareCtx, _ := c.Get("share")
share := shareCtx.(*model.Share)
userCtx, _ := c.Get("user")
user := userCtx.(*model.User)
// 不能转存自己的文件
if share.UserID == user.ID {
return serializer.Err(serializer.CodePolicyNotAllowed, "不能转存自己的分享", nil)
}
// 创建文件系统
fs, err := filesystem.NewFileSystem(user)
if err != nil {
return serializer.Err(serializer.CodePolicyNotAllowed, err.Error(), err)
}
defer fs.Recycle()
// 重设文件系统处理目标为源文件
err = fs.SetTargetByInterface(share.Source())
if err != nil {
return serializer.Err(serializer.CodePolicyNotAllowed, "源文件不存在", err)
}
err = fs.SaveTo(context.Background(), service.Path)
if err != nil {
return serializer.Err(serializer.CodeNotSet, err.Error(), err)
}
return serializer.Response{}
}
// List 列出分享的目录下的对象
func (service *Service) List(c *gin.Context) serializer.Response {
shareCtx, _ := c.Get("share")

1
service/user/login.go
View File

@@ -135,7 +135,6 @@ func (service *UserLoginService) Login(c *gin.Context) serializer.Response {
expectedUser, err := model.GetUserByEmail(service.UserName)
if model.IsTrueVal(isCaptchaRequired) {
// TODO 验证码校验
captchaID := util.GetSession(c, "captchaID")
util.DeleteSession(c, "captchaID")
if captchaID == nil || !base64Captcha.VerifyCaptcha(captchaID.(string), service.CaptchaCode) {

125
service/user/setting.go
View File

@@ -4,8 +4,6 @@ import (
"crypto/md5"
"fmt"
model "github.com/HFO4/cloudreve/models"
"github.com/HFO4/cloudreve/pkg/hashid"
"github.com/HFO4/cloudreve/pkg/qq"
"github.com/HFO4/cloudreve/pkg/serializer"
"github.com/HFO4/cloudreve/pkg/util"
"github.com/gin-gonic/gin"
@@ -14,8 +12,6 @@ import (
"net/url"
"os"
"path/filepath"
"strings"
"time"
)
// SettingService 通用设置服务
@@ -47,14 +43,6 @@ type ChangerNick struct {
Nick string `json:"nick" binding:"required,min=1,max=255"`
}
// VIPUnsubscribe 用户组解约服务
type VIPUnsubscribe struct {
}
// QQBind QQ互联服务
type QQBind struct {
}
// PolicyChange 更改存储策略
type PolicyChange struct {
ID string `json:"id" binding:"required"`
@@ -173,77 +161,6 @@ func (service *HomePage) Update(c *gin.Context, user *model.User) serializer.Res
return serializer.Response{}
}
// Update 更改用户偏好的存储策略
func (service *PolicyChange) Update(c *gin.Context, user *model.User) serializer.Response {
// 取得存储策略的ID
rawID, err := hashid.DecodeHashID(service.ID, hashid.PolicyID)
if err != nil {
return serializer.Err(serializer.CodeNotFound, "存储策略不存在", err)
}
// 用户是否可以切换到此存储策略
if !util.ContainsUint(user.Group.PolicyList, rawID) {
return serializer.Err(serializer.CodeNoPermissionErr, "存储策略不可用", nil)
}
// 查找存储策略
if _, err := model.GetPolicyByID(rawID); err != nil {
return serializer.Err(serializer.CodeNoPermissionErr, "存储策略不可用", nil)
}
// 切换存储策略
user.OptionsSerialized.PreferredPolicy = rawID
if err := user.UpdateOptions(); err != nil {
return serializer.DBErr("存储策略切换失败", err)
}
return serializer.Response{}
}
// Update 绑定或解绑QQ
func (service *QQBind) Update(c *gin.Context, user *model.User) serializer.Response {
// 解除绑定
if user.OpenID != "" {
// 只通过QQ登录的用户无法解除绑定
if strings.HasSuffix(user.Email, "@login.qq.com") {
return serializer.Err(serializer.CodeNoPermissionErr, "无法解绑此账号", nil)
}
if err := user.Update(map[string]interface{}{"open_id": ""}); err != nil {
return serializer.DBErr("接除绑定失败", err)
}
return serializer.Response{
Data: "",
}
}
// 新建绑定
res, err := qq.NewLoginRequest()
if err != nil {
return serializer.Err(serializer.CodeNotSet, "无法使用QQ登录", err)
}
// 设定QQ登录会话Secret
util.SetSession(c, map[string]interface{}{"qq_login_secret": res.SecretKey})
return serializer.Response{
Data: res.URL,
}
}
// Update 用户组解约
func (service *VIPUnsubscribe) Update(c *gin.Context, user *model.User) serializer.Response {
if user.GroupExpires != nil {
timeNow := time.Now()
if time.Now().Before(*user.GroupExpires) {
if err := user.Update(map[string]interface{}{"group_expires": &timeNow}); err != nil {
return serializer.DBErr("解约失败", err)
}
}
}
return serializer.Response{}
}
// Update 更改昵称
func (service *ChangerNick) Update(c *gin.Context, user *model.User) serializer.Response {
if err := user.Update(map[string]interface{}{"nick": service.Nick}); err != nil {
@@ -322,46 +239,16 @@ func (service *SettingListService) ListTasks(c *gin.Context, user *model.User) s
return serializer.BuildTaskList(tasks, total)
}
// Policy 获取用户存储策略设置
func (service *SettingService) Policy(c *gin.Context, user *model.User) serializer.Response {
// 取得用户可用存储策略
available := make([]model.Policy, 0, len(user.Group.PolicyList))
for _, id := range user.Group.PolicyList {
if policy, err := model.GetPolicyByID(id); err == nil {
available = append(available, policy)
}
}
// 取得用户当前策略
current := user.Policy
return serializer.BuildPolicySettingRes(available, &current)
}
// Settings 获取用户设定
func (service *SettingService) Settings(c *gin.Context, user *model.User) serializer.Response {
// 取得存储策略设定
policy := service.Policy(c, user)
// 用户组有效期
var groupExpires int64
if user.GroupExpires != nil {
if expires := user.GroupExpires.Unix() - time.Now().Unix(); expires > 0 {
groupExpires = user.GroupExpires.Unix()
}
}
return serializer.Response{
Data: map[string]interface{}{
"policy": policy.Data.(map[string]interface{}),
"uid": user.ID,
"qq": user.OpenID != "",
"homepage": !user.OptionsSerialized.ProfileOff,
"two_factor": user.TwoFactor != "",
"prefer_theme": user.OptionsSerialized.PreferredTheme,
"themes": model.GetSettingByName("themes"),
"group_expires": groupExpires,
"authn": serializer.BuildWebAuthnList(user.WebAuthnCredentials()),
"uid": user.ID,
"homepage": !user.OptionsSerialized.ProfileOff,
"two_factor": user.TwoFactor != "",
"prefer_theme": user.OptionsSerialized.PreferredTheme,
"themes": model.GetSettingByName("themes"),
"authn": serializer.BuildWebAuthnList(user.WebAuthnCredentials()),
},
}
}

219
service/vas/purchase.go
View File

@@ -1,219 +0,0 @@
package vas
import (
"encoding/json"
model "github.com/HFO4/cloudreve/models"
"github.com/HFO4/cloudreve/pkg/payment"
"github.com/HFO4/cloudreve/pkg/serializer"
"github.com/gin-gonic/gin"
)
// CreateOrderService 创建订单服务
type CreateOrderService struct {
Action string `json:"action" binding:"required,eq=group|eq=pack|eq=score"`
Method string `json:"method" binding:"required,eq=alipay|eq=score|eq=payjs"`
ID int64 `json:"id" binding:"required"`
Num int `json:"num" binding:"required,min=1"`
}
// RedeemService 兑换服务
type RedeemService struct {
Code string `uri:"code" binding:"required,max=64"`
}
// OrderService 订单查询
type OrderService struct {
ID string `uri:"id" binding:"required"`
}
// Status 查询订单状态
func (service *OrderService) Status(c *gin.Context, user *model.User) serializer.Response {
order, _ := model.GetOrderByNo(service.ID)
if order == nil || order.UserID != user.ID {
return serializer.Err(serializer.CodeNotFound, "订单不存在", nil)
}
return serializer.Response{Data: order.Status}
}
// Redeem 开始兑换
func (service *RedeemService) Redeem(c *gin.Context, user *model.User) serializer.Response {
redeem, err := model.GetAvailableRedeem(service.Code)
if err != nil {
return serializer.Err(serializer.CodeDBError, "兑换码无效", err)
}
// 取得当前商品信息
packs, groups, err := decodeProductInfo()
if err != nil {
return serializer.Err(serializer.CodeInternalSetting, "无法解析商品设置", err)
}
// 查找要购买的商品
var (
pack *serializer.PackProduct
group *serializer.GroupProducts
)
if redeem.Type == model.GroupOrderType {
for _, v := range groups {
if v.ID == redeem.ProductID {
group = &v
break
}
}
if group == nil {
return serializer.Err(serializer.CodeNotFound, "商品已失效", err)
}
} else if redeem.Type == model.PackOrderType {
for _, v := range packs {
if v.ID == redeem.ProductID {
pack = &v
break
}
}
if pack == nil {
return serializer.Err(serializer.CodeNotFound, "商品已失效", err)
}
}
err = payment.GiveProduct(user, pack, group, redeem.Num)
if err != nil {
return serializer.Err(serializer.CodeNotSet, "兑换失败", err)
}
redeem.Use()
return serializer.Response{}
}
// Query 检查兑换码信息
func (service *RedeemService) Query(c *gin.Context) serializer.Response {
redeem, err := model.GetAvailableRedeem(service.Code)
if err != nil {
return serializer.Err(serializer.CodeDBError, "兑换码无效", err)
}
var (
name = "积分"
productTime int64
)
if redeem.Type != model.ScoreOrderType {
packs, groups, err := decodeProductInfo()
if err != nil {
return serializer.Err(serializer.CodeInternalSetting, "无法解析商品设置", err)
}
if redeem.Type == model.GroupOrderType {
for _, v := range groups {
if v.ID == redeem.ProductID {
name = v.Name
productTime = v.Time
break
}
}
} else {
for _, v := range packs {
if v.ID == redeem.ProductID {
name = v.Name
productTime = v.Time
break
}
}
}
if name == "积分" {
return serializer.Err(serializer.CodeNotFound, "商品已失效", err)
}
}
return serializer.Response{
Data: struct {
Name string `json:"name"`
Type int `json:"type"`
Num int `json:"num"`
Time int64 `json:"time"`
}{
name, redeem.Type, redeem.Num, productTime,
},
}
}
// Create 创建新订单
func (service *CreateOrderService) Create(c *gin.Context, user *model.User) serializer.Response {
// 取得当前商品信息
packs, groups, err := decodeProductInfo()
if err != nil {
return serializer.Err(serializer.CodeInternalSetting, "无法解析商品设置", err)
}
// 查找要购买的商品
var (
pack *serializer.PackProduct
group *serializer.GroupProducts
)
if service.Action == "group" {
for _, v := range groups {
if v.ID == service.ID {
group = &v
break
}
}
} else if service.Action == "pack" {
for _, v := range packs {
if v.ID == service.ID {
pack = &v
break
}
}
}
// 购买积分
if pack == nil && group == nil {
if service.Method == "score" {
return serializer.Err(serializer.CodeNotFound, "不支持此支付方式", nil)
}
}
// 创建订单
res, err := payment.NewOrder(pack, group, service.Num, service.Method, user)
if err != nil {
return serializer.Err(serializer.CodeNotSet, err.Error(), err)
}
return serializer.Response{Data: res}
}
// Products 获取商品信息
func (service *GeneralVASService) Products(c *gin.Context, user *model.User) serializer.Response {
options := model.GetSettingByNames("alipay_enabled", "payjs_enabled", "score_price")
scorePrice := model.GetIntSetting("score_price", 0)
packs, groups, err := decodeProductInfo()
if err != nil {
return serializer.Err(serializer.CodeInternalSetting, "无法解析商品设置", err)
}
return serializer.BuildProductResponse(groups, packs, options["alipay_enabled"] == "1", options["payjs_enabled"] == "1", scorePrice)
}
func decodeProductInfo() ([]serializer.PackProduct, []serializer.GroupProducts, error) {
options := model.GetSettingByNames("pack_data", "group_sell_data", "alipay_enabled", "payjs_enabled")
var (
packs []serializer.PackProduct
groups []serializer.GroupProducts
)
if err := json.Unmarshal([]byte(options["pack_data"]), &packs); err != nil {
return nil, nil, err
}
if err := json.Unmarshal([]byte(options["group_sell_data"]), &groups); err != nil {
return nil, nil, err
}
return packs, groups, nil
}

107
service/vas/qq.go
View File

@@ -1,107 +0,0 @@
package vas
import (
model "github.com/HFO4/cloudreve/models"
"github.com/HFO4/cloudreve/pkg/qq"
"github.com/HFO4/cloudreve/pkg/request"
"github.com/HFO4/cloudreve/pkg/serializer"
"github.com/HFO4/cloudreve/pkg/thumb"
"github.com/HFO4/cloudreve/pkg/util"
"github.com/gin-gonic/gin"
)
// QQCallbackService QQ互联回调处理服务
type QQCallbackService struct {
Code string `json:"code" binding:"required"`
State string `json:"state" binding:"required"`
}
// Callback 处理QQ互联回调
func (service *QQCallbackService) Callback(c *gin.Context, user *model.User) serializer.Response {
state := util.GetSession(c, "qq_login_secret")
if stateStr, ok := state.(string); !ok || stateStr != service.State {
return serializer.Err(serializer.CodeSignExpired, "请求过期，请重试", nil)
}
util.DeleteSession(c, "qq_login_secret")
// 获取OpenID
credential, err := qq.Callback(service.Code)
if err != nil {
return serializer.Err(serializer.CodeNotSet, "无法获取登录状态", err)
}
// 如果已登录，则绑定已有用户
if user != nil {
if user.OpenID != "" {
return serializer.Err(serializer.CodeCallbackError, "您已绑定了QQ账号，请先解除绑定", nil)
}
if err := user.Update(map[string]interface{}{"open_id": credential.OpenID}); err != nil {
return serializer.DBErr("绑定失败", err)
}
return serializer.Response{
Data: "/setting",
}
}
// 未登录，尝试查找用户
if expectedUser, err := model.GetActiveUserByOpenID(credential.OpenID); err == nil {
// 用户绑定了此QQ，设定为登录状态
util.SetSession(c, map[string]interface{}{
"user_id": expectedUser.ID,
})
res := serializer.BuildUserResponse(expectedUser)
res.Code = 203
return res
}
// 无匹配用户，创建新用户
if !model.IsTrueVal(model.GetSettingByName("qq_direct_login")) {
return serializer.Err(serializer.CodeNoPermissionErr, "此QQ号未绑定任何账号", nil)
}
// 获取用户信息
userInfo, err := qq.GetUserInfo(credential)
if err != nil {
return serializer.Err(serializer.CodeNotSet, "无法获取用户信息", err)
}
// 生成邮箱地址
fakeEmail := util.RandStringRunes(16) + "@login.qq.com"
// 创建用户
defaultGroup := model.GetIntSetting("default_group", 2)
newUser := model.NewUser()
newUser.Email = fakeEmail
newUser.Nick = userInfo.Nick
newUser.SetPassword("")
newUser.Status = model.Active
newUser.GroupID = uint(defaultGroup)
newUser.OpenID = credential.OpenID
newUser.Avatar = "file"
// 创建用户
if err := model.DB.Create(&newUser).Error; err != nil {
return serializer.DBErr("此邮箱已被使用", err)
}
// 下载头像
r := request.HTTPClient{}
rawAvatar := r.Request("GET", userInfo.Avatar, nil)
if avatar, err := thumb.NewThumbFromFile(rawAvatar.Response.Body, "avatar.jpg"); err == nil {
avatar.CreateAvatar(newUser.ID)
}
// 登录
util.SetSession(c, map[string]interface{}{"user_id": newUser.ID})
newUser, _ = model.GetActiveUserByID(newUser.ID)
res := serializer.BuildUserResponse(newUser)
res.Code = 203
return res
}

17
service/vas/quota.go
View File

@@ -1,17 +0,0 @@
package vas
import (
model "github.com/HFO4/cloudreve/models"
"github.com/HFO4/cloudreve/pkg/serializer"
"github.com/gin-gonic/gin"
)
// GeneralVASService 通用增值服务
type GeneralVASService struct {
}
// Quota 获取容量配额信息
func (service *GeneralVASService) Quota(c *gin.Context, user *model.User) serializer.Response {
packs := user.GetAvailableStoragePacks()
return serializer.BuildUserQuotaResponse(user, packs)
}