Client/server
5
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

init: 1.0.0

Browse Source
This commit is contained in:
tension
2025-04-25 12:08:29 +09:00
commit c81c9bd724
1031 changed files with 76472 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
internal/logic/admin/user/batchDeleteUserLogic.go
+34
View File
@@ -0,0 +1,34 @@
package user
import (
"context"
"github.com/perfect-panel/ppanel-server/internal/svc"
"github.com/perfect-panel/ppanel-server/internal/types"
"github.com/perfect-panel/ppanel-server/pkg/logger"
"github.com/perfect-panel/ppanel-server/pkg/xerr"
"github.com/pkg/errors"
)
type BatchDeleteUserLogic struct {
ctx context.Context
svcCtx *svc.ServiceContext
logger.Logger
}
func NewBatchDeleteUserLogic(ctx context.Context, svcCtx *svc.ServiceContext) *BatchDeleteUserLogic {
return &BatchDeleteUserLogic{
ctx: ctx,
svcCtx: svcCtx,
Logger: logger.WithContext(ctx),
}
}
func (l *BatchDeleteUserLogic) BatchDeleteUser(req *types.BatchDeleteUserRequest) error {
err := l.svcCtx.UserModel.BatchDeleteUser(l.ctx, req.Ids)
if err != nil {
l.Logger.Error("[BatchDeleteUserLogic] BatchDeleteUser failed: ", logger.Field("error", err.Error()))
return errors.Wrapf(xerr.NewErrCode(xerr.DatabaseDeletedError), "BatchDeleteUser failed: %v", err.Error())
}
return nil
}
internal/logic/admin/user/createUserAuthMethodLogic.go
+50
View File
@@ -0,0 +1,50 @@
package user
import (
"context"
"github.com/perfect-panel/ppanel-server/internal/model/user"
"github.com/perfect-panel/ppanel-server/pkg/xerr"
"github.com/pkg/errors"
"gorm.io/gorm"
"github.com/perfect-panel/ppanel-server/internal/svc"
"github.com/perfect-panel/ppanel-server/internal/types"
"github.com/perfect-panel/ppanel-server/pkg/logger"
)
type CreateUserAuthMethodLogic struct {
logger.Logger
ctx context.Context
svcCtx *svc.ServiceContext
}
// Create user auth method
func NewCreateUserAuthMethodLogic(ctx context.Context, svcCtx *svc.ServiceContext) *CreateUserAuthMethodLogic {
return &CreateUserAuthMethodLogic{
Logger: logger.WithContext(ctx),
ctx: ctx,
svcCtx: svcCtx,
}
}
func (l *CreateUserAuthMethodLogic) CreateUserAuthMethod(req *types.CreateUserAuthMethodRequest) error {
err := l.svcCtx.UserModel.Transaction(l.ctx, func(db *gorm.DB) error {
var data *user.AuthMethods
if err := db.Model(&user.AuthMethods{}).Where("`user_id` = ? AND `auth_type` = ?", req.UserId, req.AuthType).First(&data).Error; err != nil && errors.Is(err, gorm.ErrRecordNotFound) {
return err
}
data.UserId = req.UserId
data.AuthType = req.AuthType
data.AuthIdentifier = req.AuthIdentifier
if err := db.Model(&user.AuthMethods{}).Save(&data).Error; err != nil {
return err
}
return nil
})
if err != nil {
l.Errorw("[CreateUserAuthMethodLogic] Create User Auth Method Error:", logger.Field("error", err.Error()))
return errors.Wrapf(xerr.NewErrCode(xerr.DatabaseInsertError), "Create User Auth Method Error")
}
return nil
}
internal/logic/admin/user/createUserLogic.go
+91
View File
@@ -0,0 +1,91 @@
package user
import (
"context"
"fmt"
"time"
"github.com/perfect-panel/ppanel-server/internal/model/user"
"github.com/perfect-panel/ppanel-server/internal/svc"
"github.com/perfect-panel/ppanel-server/internal/types"
"github.com/perfect-panel/ppanel-server/pkg/logger"
"github.com/perfect-panel/ppanel-server/pkg/tool"
"github.com/perfect-panel/ppanel-server/pkg/uuidx"
"github.com/perfect-panel/ppanel-server/pkg/xerr"
"github.com/pkg/errors"
"gorm.io/gorm"
)
type CreateUserLogic struct {
ctx context.Context
svcCtx *svc.ServiceContext
logger.Logger
}
func NewCreateUserLogic(ctx context.Context, svcCtx *svc.ServiceContext) *CreateUserLogic {
return &CreateUserLogic{
ctx: ctx,
svcCtx: svcCtx,
Logger: logger.WithContext(ctx),
}
}
func (l *CreateUserLogic) CreateUser(req *types.CreateUserRequest) error {
if req.ReferCode == "" {
// timestamp replaces user id
req.ReferCode = uuidx.UserInviteCode(time.Now().UnixMicro())
}
if req.Password == "" {
req.Password = req.Email
}
pwd := tool.EncodePassWord(req.Password)
newUser := &user.User{
Password: pwd,
ReferCode: req.ReferCode,
Balance: req.Balance,
IsAdmin: &req.IsAdmin,
}
var ams []user.AuthMethods
if req.TelephoneAreaCode != "" && req.Telephone != "" {
phone := fmt.Sprintf("%s-%s", req.TelephoneAreaCode, req.Telephone)
_, err := l.svcCtx.UserModel.FindUserAuthMethodByOpenID(l.ctx, "mobile", phone)
if err == nil {
return errors.Wrapf(xerr.NewErrCode(xerr.TelephoneExist), "telephone exist")
}
ams = append(ams, user.AuthMethods{
AuthType: "mobile",
AuthIdentifier: phone,
})
}
if req.Email != "" {
_, err := l.svcCtx.UserModel.FindUserAuthMethodByOpenID(l.ctx, "email", req.Email)
if err == nil {
return errors.Wrapf(xerr.NewErrCode(xerr.EmailExist), "email exist")
}
ams = append(ams, user.AuthMethods{
AuthType: "email",
AuthIdentifier: req.Email,
})
}
newUser.AuthMethods = ams
// todo: get product id and duration
if req.RefererUser != "" {
// get referer user id
u, err := l.svcCtx.UserModel.FindOneByEmail(l.ctx, req.RefererUser)
if err != nil {
if errors.Is(err, gorm.ErrRecordNotFound) {
return errors.Wrapf(xerr.NewErrCode(xerr.UserNotExist), "referer user not found: %v", err.Error())
}
return errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "find referer user failed: %v", err.Error())
}
newUser.RefererId = u.Id
}
err := l.svcCtx.UserModel.Insert(l.ctx, newUser)
if err != nil {
return errors.Wrapf(xerr.NewErrCode(xerr.DatabaseInsertError), "insert user failed: %v", err.Error())
}
return nil
}
internal/logic/admin/user/createUserSubscribeLogic.go
+81
View File
@@ -0,0 +1,81 @@
package user
import (
"context"
"fmt"
"time"
"github.com/google/uuid"
"github.com/perfect-panel/ppanel-server/internal/model/user"
"github.com/perfect-panel/ppanel-server/internal/svc"
"github.com/perfect-panel/ppanel-server/internal/types"
"github.com/perfect-panel/ppanel-server/pkg/logger"
"github.com/perfect-panel/ppanel-server/pkg/uuidx"
"github.com/perfect-panel/ppanel-server/pkg/xerr"
"github.com/pkg/errors"
)
type CreateUserSubscribeLogic struct {
logger.Logger
ctx context.Context
svcCtx *svc.ServiceContext
}
// Create user subcribe
func NewCreateUserSubscribeLogic(ctx context.Context, svcCtx *svc.ServiceContext) *CreateUserSubscribeLogic {
return &CreateUserSubscribeLogic{
Logger: logger.WithContext(ctx),
ctx: ctx,
svcCtx: svcCtx,
}
}
func (l *CreateUserSubscribeLogic) CreateUserSubscribe(req *types.CreateUserSubscribeRequest) error {
// validate user
userInfo, err := l.svcCtx.UserModel.FindOne(l.ctx, req.UserId)
if err != nil {
l.Errorw("FindOne error", logger.Field("error", err.Error()), logger.Field("userId", req.UserId))
return errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "FindOne error: %v", err.Error())
}
subs, err := l.svcCtx.UserModel.QueryUserSubscribe(l.ctx, req.UserId)
if err != nil {
l.Errorw("QueryUserSubscribe error", logger.Field("error", err.Error()), logger.Field("userId", req.UserId))
return errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "QueryUserSubscribe error: %v", err.Error())
}
if len(subs) >= 1 && l.svcCtx.Config.Subscribe.SingleModel {
return errors.Wrapf(xerr.NewErrCode(xerr.SingleSubscribeModeExceedsLimit), "Single subscribe mode exceeds limit")
}
sub, err := l.svcCtx.SubscribeModel.FindOne(l.ctx, req.SubscribeId)
if err != nil {
l.Errorw("FindOne error", logger.Field("error", err.Error()), logger.Field("subscribeId", req.SubscribeId))
return errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "FindOne error: %v", err.Error())
}
if req.Traffic == 0 {
req.Traffic = sub.Traffic
}
userSub := user.Subscribe{
UserId: req.UserId,
SubscribeId: req.SubscribeId,
StartTime: time.Now(),
ExpireTime: time.UnixMilli(req.ExpiredAt),
Traffic: req.Traffic,
Download: 0,
Upload: 0,
Token: uuidx.SubscribeToken(fmt.Sprintf("adminCreate:%d", time.Now().UnixMilli())),
UUID: uuid.New().String(),
Status: 1,
}
if err = l.svcCtx.UserModel.InsertSubscribe(l.ctx, &userSub); err != nil {
l.Errorw("InsertSubscribe error", logger.Field("error", err.Error()))
return errors.Wrapf(xerr.NewErrCode(xerr.DatabaseInsertError), "InsertSubscribe error: %v", err.Error())
}
err = l.svcCtx.UserModel.UpdateUserCache(l.ctx, userInfo)
if err != nil {
l.Errorw("UpdateUserCache error", logger.Field("error", err.Error()))
return errors.Wrapf(xerr.NewErrCode(xerr.DatabaseInsertError), "UpdateUserCache error: %v", err.Error())
}
return nil
}
internal/logic/admin/user/currentUserLogic.go
+44
View File
@@ -0,0 +1,44 @@
package user
import (
"context"
"github.com/perfect-panel/ppanel-server/pkg/constant"
"github.com/perfect-panel/ppanel-server/pkg/xerr"
"github.com/pkg/errors"
"github.com/perfect-panel/ppanel-server/internal/model/user"
"github.com/perfect-panel/ppanel-server/internal/svc"
"github.com/perfect-panel/ppanel-server/internal/types"
"github.com/perfect-panel/ppanel-server/pkg/logger"
"github.com/perfect-panel/ppanel-server/pkg/tool"
"go.uber.org/zap"
"go.uber.org/zap/zapcore"
)
type CurrentUserLogic struct {
ctx context.Context
svcCtx *svc.ServiceContext
logger.Logger
}
func NewCurrentUserLogic(ctx context.Context, svcCtx *svc.ServiceContext) *CurrentUserLogic {
return &CurrentUserLogic{
ctx: ctx,
svcCtx: svcCtx,
Logger: logger.WithContext(ctx),
}
}
func (l *CurrentUserLogic) CurrentUser() (*types.User, error) {
resp := &types.User{}
u, ok := l.ctx.Value(constant.CtxKeyUser).(*user.User)
if !ok {
logger.Error("current user is not found in context")
return nil, errors.Wrapf(xerr.NewErrCode(xerr.InvalidAccess), "Invalid Access")
}
l.Logger.Info("current user", zap.Field{Key: "userId", Type: zapcore.Int64Type, Integer: u.Id})
tool.DeepCopy(resp, u)
return resp, nil
}
internal/logic/admin/user/deleteUserAuthMethodLogic.go
+35
View File
@@ -0,0 +1,35 @@
package user
import (
"context"
"github.com/perfect-panel/ppanel-server/internal/svc"
"github.com/perfect-panel/ppanel-server/internal/types"
"github.com/perfect-panel/ppanel-server/pkg/logger"
"github.com/perfect-panel/ppanel-server/pkg/xerr"
"github.com/pkg/errors"
)
type DeleteUserAuthMethodLogic struct {
logger.Logger
ctx context.Context
svcCtx *svc.ServiceContext
}
// Delete user auth method
func NewDeleteUserAuthMethodLogic(ctx context.Context, svcCtx *svc.ServiceContext) *DeleteUserAuthMethodLogic {
return &DeleteUserAuthMethodLogic{
Logger: logger.WithContext(ctx),
ctx: ctx,
svcCtx: svcCtx,
}
}
func (l *DeleteUserAuthMethodLogic) DeleteUserAuthMethod(req *types.DeleteUserAuthMethodRequest) error {
err := l.svcCtx.UserModel.DeleteUserAuthMethods(l.ctx, req.UserId, req.AuthType)
if err != nil {
l.Errorw("[DeleteUserAuthMethodLogic] Delete User Auth Method Error:", logger.Field("err", err.Error()), logger.Field("userId", req.UserId), logger.Field("authType", req.AuthType))
return errors.Wrapf(xerr.NewErrCode(xerr.DatabaseDeletedError), "Delete User Auth Method Error")
}
return nil
}
internal/logic/admin/user/deleteUserDeviceLogic.go
+35
View File
@@ -0,0 +1,35 @@
package user
import (
"context"
"github.com/perfect-panel/ppanel-server/pkg/xerr"
"github.com/pkg/errors"
"github.com/perfect-panel/ppanel-server/internal/svc"
"github.com/perfect-panel/ppanel-server/internal/types"
"github.com/perfect-panel/ppanel-server/pkg/logger"
)
type DeleteUserDeviceLogic struct {
logger.Logger
ctx context.Context
svcCtx *svc.ServiceContext
}
// Delete user device
func NewDeleteUserDeviceLogic(ctx context.Context, svcCtx *svc.ServiceContext) *DeleteUserDeviceLogic {
return &DeleteUserDeviceLogic{
Logger: logger.WithContext(ctx),
ctx: ctx,
svcCtx: svcCtx,
}
}
func (l *DeleteUserDeviceLogic) DeleteUserDevice(req *types.DeleteUserDeivceRequest) error {
err := l.svcCtx.UserModel.DeleteDevice(l.ctx, req.Id)
if err != nil {
return errors.Wrapf(xerr.NewErrCode(xerr.DatabaseDeletedError), "delete user error: %v", err.Error())
}
return nil
}
internal/logic/admin/user/deleteUserLogic.go
+33
View File
@@ -0,0 +1,33 @@
package user
import (
"context"
"github.com/perfect-panel/ppanel-server/internal/svc"
"github.com/perfect-panel/ppanel-server/internal/types"
"github.com/perfect-panel/ppanel-server/pkg/logger"
"github.com/perfect-panel/ppanel-server/pkg/xerr"
"github.com/pkg/errors"
)
type DeleteUserLogic struct {
ctx context.Context
svcCtx *svc.ServiceContext
logger.Logger
}
func NewDeleteUserLogic(ctx context.Context, svcCtx *svc.ServiceContext) *DeleteUserLogic {
return &DeleteUserLogic{
ctx: ctx,
svcCtx: svcCtx,
Logger: logger.WithContext(ctx),
}
}
func (l *DeleteUserLogic) DeleteUser(req *types.GetDetailRequest) error {
err := l.svcCtx.UserModel.Delete(l.ctx, req.Id)
if err != nil {
return errors.Wrapf(xerr.NewErrCode(xerr.DatabaseDeletedError), "delete user error: %v", err.Error())
}
return nil
}
internal/logic/admin/user/deleteUserSubscribeLogic.go
+35
View File
@@ -0,0 +1,35 @@
package user
import (
"context"
"github.com/perfect-panel/ppanel-server/internal/svc"
"github.com/perfect-panel/ppanel-server/internal/types"
"github.com/perfect-panel/ppanel-server/pkg/logger"
"github.com/perfect-panel/ppanel-server/pkg/xerr"
"github.com/pkg/errors"
)
type DeleteUserSubscribeLogic struct {
logger.Logger
ctx context.Context
svcCtx *svc.ServiceContext
}
// NewDeleteUserSubscribeLogic Delete user subcribe
func NewDeleteUserSubscribeLogic(ctx context.Context, svcCtx *svc.ServiceContext) *DeleteUserSubscribeLogic {
return &DeleteUserSubscribeLogic{
Logger: logger.WithContext(ctx),
ctx: ctx,
svcCtx: svcCtx,
}
}
func (l *DeleteUserSubscribeLogic) DeleteUserSubscribe(req *types.DeleteUserSubscribeRequest) error {
err := l.svcCtx.UserModel.DeleteSubscribeById(l.ctx, req.UserSubscribeId)
if err != nil {
l.Errorw("failed to delete user subscribe", logger.Field("error", err.Error()), logger.Field("userSubscribeId", req.UserSubscribeId))
return errors.Wrapf(xerr.NewErrCode(xerr.DatabaseDeletedError), "failed to delete user subscribe: %v", err.Error())
}
return nil
}
internal/logic/admin/user/getUserAuthMethodLogic.go
+41
View File
@@ -0,0 +1,41 @@
package user
import (
"context"
"github.com/perfect-panel/ppanel-server/internal/svc"
"github.com/perfect-panel/ppanel-server/internal/types"
"github.com/perfect-panel/ppanel-server/pkg/logger"
"github.com/perfect-panel/ppanel-server/pkg/tool"
"github.com/perfect-panel/ppanel-server/pkg/xerr"
"github.com/pkg/errors"
)
type GetUserAuthMethodLogic struct {
logger.Logger
ctx context.Context
svcCtx *svc.ServiceContext
}
// Get user auth method
func NewGetUserAuthMethodLogic(ctx context.Context, svcCtx *svc.ServiceContext) *GetUserAuthMethodLogic {
return &GetUserAuthMethodLogic{
Logger: logger.WithContext(ctx),
ctx: ctx,
svcCtx: svcCtx,
}
}
func (l *GetUserAuthMethodLogic) GetUserAuthMethod(req *types.GetUserAuthMethodRequest) (resp *types.GetUserAuthMethodResponse, err error) {
methods, err := l.svcCtx.UserModel.FindUserAuthMethods(l.ctx, req.UserId)
if err != nil {
l.Errorw("[GetUserAuthMethodLogic] Get User Auth Method Error:", logger.Field("err", err.Error()))
return nil, errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "Get User Auth Method Error")
}
list := make([]types.UserAuthMethod, 0)
tool.DeepCopy(&list, methods)
return &types.GetUserAuthMethodResponse{
AuthMethods: list,
}, nil
}
internal/logic/admin/user/getUserDetailLogic.go
+36
View File
@@ -0,0 +1,36 @@
package user
import (
"context"
"github.com/perfect-panel/ppanel-server/internal/svc"
"github.com/perfect-panel/ppanel-server/internal/types"
"github.com/perfect-panel/ppanel-server/pkg/logger"
"github.com/perfect-panel/ppanel-server/pkg/tool"
"github.com/perfect-panel/ppanel-server/pkg/xerr"
"github.com/pkg/errors"
)
type GetUserDetailLogic struct {
ctx context.Context
svcCtx *svc.ServiceContext
logger.Logger
}
func NewGetUserDetailLogic(ctx context.Context, svcCtx *svc.ServiceContext) *GetUserDetailLogic {
return &GetUserDetailLogic{
ctx: ctx,
svcCtx: svcCtx,
Logger: logger.WithContext(ctx),
}
}
func (l *GetUserDetailLogic) GetUserDetail(req *types.GetDetailRequest) (*types.User, error) {
resp := types.User{}
userInfo, err := l.svcCtx.UserModel.FindOne(l.ctx, req.Id)
if err != nil {
return nil, errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "get user detail error: %v", err.Error())
}
tool.DeepCopy(&resp, userInfo)
return &resp, nil
}
internal/logic/admin/user/getUserListLogic.go
+63
View File
@@ -0,0 +1,63 @@
package user
import (
"context"
"github.com/perfect-panel/ppanel-server/internal/model/user"
"github.com/perfect-panel/ppanel-server/internal/svc"
"github.com/perfect-panel/ppanel-server/internal/types"
"github.com/perfect-panel/ppanel-server/pkg/logger"
"github.com/perfect-panel/ppanel-server/pkg/phone"
"github.com/perfect-panel/ppanel-server/pkg/tool"
"github.com/perfect-panel/ppanel-server/pkg/xerr"
"github.com/pkg/errors"
)
type GetUserListLogic struct {
ctx context.Context
svcCtx *svc.ServiceContext
logger.Logger
}
func NewGetUserListLogic(ctx context.Context, svcCtx *svc.ServiceContext) *GetUserListLogic {
return &GetUserListLogic{
ctx: ctx,
svcCtx: svcCtx,
Logger: logger.WithContext(ctx),
}
}
func (l *GetUserListLogic) GetUserList(req *types.GetUserListRequest) (*types.GetUserListResponse, error) {
list, total, err := l.svcCtx.UserModel.QueryPageList(l.ctx, req.Page, req.Size, &user.UserFilterParams{
UserId: req.UserId,
Search: req.Search,
SubscribeId: req.SubscribeId,
UserSubscribeId: req.UserSubscribeId,
})
if err != nil {
return nil, errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "GetUserListLogic failed: %v", err.Error())
}
userRespList := make([]types.User, 0, len(list))
for _, item := range list {
var user types.User
tool.DeepCopy(&user, item)
// 处理 AuthMethods
authMethods := make([]types.UserAuthMethod, len(user.AuthMethods)) // 直接创建目标 slice
for i, method := range user.AuthMethods {
tool.DeepCopy(&authMethods[i], method)
if method.AuthType == "mobile" {
authMethods[i].AuthIdentifier = phone.FormatToInternational(method.AuthIdentifier)
}
}
user.AuthMethods = authMethods
userRespList = append(userRespList, user)
}
return &types.GetUserListResponse{
Total: total,
List: userRespList,
}, nil
}
internal/logic/admin/user/getUserLoginLogsLogic.go
+44
View File
@@ -0,0 +1,44 @@
package user
import (
"context"
"github.com/perfect-panel/ppanel-server/internal/model/user"
"github.com/perfect-panel/ppanel-server/internal/svc"
"github.com/perfect-panel/ppanel-server/internal/types"
"github.com/perfect-panel/ppanel-server/pkg/logger"
"github.com/perfect-panel/ppanel-server/pkg/tool"
"github.com/perfect-panel/ppanel-server/pkg/xerr"
"github.com/pkg/errors"
)
type GetUserLoginLogsLogic struct {
logger.Logger
ctx context.Context
svcCtx *svc.ServiceContext
}
// Get user login logs
func NewGetUserLoginLogsLogic(ctx context.Context, svcCtx *svc.ServiceContext) *GetUserLoginLogsLogic {
return &GetUserLoginLogsLogic{
Logger: logger.WithContext(ctx),
ctx: ctx,
svcCtx: svcCtx,
}
}
func (l *GetUserLoginLogsLogic) GetUserLoginLogs(req *types.GetUserLoginLogsRequest) (resp *types.GetUserLoginLogsResponse, err error) {
data, total, err := l.svcCtx.UserModel.FilterLoginLogList(l.ctx, req.Page, req.Size, &user.LoginLogFilterParams{
UserId: req.UserId,
})
if err != nil {
l.Errorw("[GetUserLoginLogs] get user login logs failed", logger.Field("error", err.Error()), logger.Field("request", req))
return nil, errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "get user login logs failed: %v", err.Error())
}
var list []types.UserLoginLog
tool.DeepCopy(&list, data)
return &types.GetUserLoginLogsResponse{
Total: total,
List: list,
}, nil
}
internal/logic/admin/user/getUserSubscribeByIdLogic.go
+38
View File
@@ -0,0 +1,38 @@
package user
import (
"context"
"github.com/perfect-panel/ppanel-server/internal/svc"
"github.com/perfect-panel/ppanel-server/internal/types"
"github.com/perfect-panel/ppanel-server/pkg/logger"
"github.com/perfect-panel/ppanel-server/pkg/tool"
"github.com/perfect-panel/ppanel-server/pkg/xerr"
"github.com/pkg/errors"
)
type GetUserSubscribeByIdLogic struct {
logger.Logger
ctx context.Context
svcCtx *svc.ServiceContext
}
// Get user subcribe by id
func NewGetUserSubscribeByIdLogic(ctx context.Context, svcCtx *svc.ServiceContext) *GetUserSubscribeByIdLogic {
return &GetUserSubscribeByIdLogic{
Logger: logger.WithContext(ctx),
ctx: ctx,
svcCtx: svcCtx,
}
}
func (l *GetUserSubscribeByIdLogic) GetUserSubscribeById(req *types.GetUserSubscribeByIdRequest) (resp *types.UserSubscribeDetail, err error) {
sub, err := l.svcCtx.UserModel.FindOneSubscribeDetailsById(l.ctx, req.Id)
if err != nil {
l.Errorw("[GetUserSubscribeByIdLogic] FindOneSubscribeDetailsById error", logger.Field("error", err.Error()))
return nil, errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "FindOneSubscribeDetailsById error: %v", err.Error())
}
var subscribeDetails types.UserSubscribeDetail
tool.DeepCopy(&subscribeDetails, sub)
return &subscribeDetails, nil
}
internal/logic/admin/user/getUserSubscribeDevicesLogic.go
+41
View File
@@ -0,0 +1,41 @@
package user
import (
"context"
"github.com/perfect-panel/ppanel-server/pkg/tool"
"github.com/perfect-panel/ppanel-server/pkg/xerr"
"github.com/pkg/errors"
"github.com/perfect-panel/ppanel-server/internal/svc"
"github.com/perfect-panel/ppanel-server/internal/types"
"github.com/perfect-panel/ppanel-server/pkg/logger"
)
type GetUserSubscribeDevicesLogic struct {
logger.Logger
ctx context.Context
svcCtx *svc.ServiceContext
}
// Get user subcribe devices
func NewGetUserSubscribeDevicesLogic(ctx context.Context, svcCtx *svc.ServiceContext) *GetUserSubscribeDevicesLogic {
return &GetUserSubscribeDevicesLogic{
Logger: logger.WithContext(ctx),
ctx: ctx,
svcCtx: svcCtx,
}
}
func (l *GetUserSubscribeDevicesLogic) GetUserSubscribeDevices(req *types.GetUserSubscribeDevicesRequest) (resp *types.GetUserSubscribeDevicesResponse, err error) {
list, total, err := l.svcCtx.UserModel.QueryDevicePageList(l.ctx, req.UserId, req.SubscribeId, req.Page, req.Size)
if err != nil {
return nil, errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "GetUserSubscribeDevices failed: %v", err.Error())
}
userRespList := make([]types.UserDevice, 0)
tool.DeepCopy(&userRespList, list)
return &types.GetUserSubscribeDevicesResponse{
Total: total,
List: userRespList,
}, nil
}
internal/logic/admin/user/getUserSubscribeLogic.go
+47
View File
@@ -0,0 +1,47 @@
package user
import (
"context"
"github.com/perfect-panel/ppanel-server/internal/svc"
"github.com/perfect-panel/ppanel-server/internal/types"
"github.com/perfect-panel/ppanel-server/pkg/logger"
"github.com/perfect-panel/ppanel-server/pkg/tool"
"github.com/perfect-panel/ppanel-server/pkg/xerr"
"github.com/pkg/errors"
)
type GetUserSubscribeLogic struct {
logger.Logger
ctx context.Context
svcCtx *svc.ServiceContext
}
// Get user subcribe
func NewGetUserSubscribeLogic(ctx context.Context, svcCtx *svc.ServiceContext) *GetUserSubscribeLogic {
return &GetUserSubscribeLogic{
Logger: logger.WithContext(ctx),
ctx: ctx,
svcCtx: svcCtx,
}
}
func (l *GetUserSubscribeLogic) GetUserSubscribe(req *types.GetUserSubscribeListRequest) (resp *types.GetUserSubscribeListResponse, err error) {
data, err := l.svcCtx.UserModel.QueryUserSubscribe(l.ctx, req.UserId, 0, 1, 2, 3, 4)
if err != nil {
l.Errorw("[GetUserSubscribeLogs] Get User Subscribe Error:", logger.Field("err", err.Error()))
return nil, errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "Get User Subscribe Error")
}
resp = &types.GetUserSubscribeListResponse{
List: make([]types.UserSubscribe, 0),
Total: int64(len(data)),
}
for _, item := range data {
var sub types.UserSubscribe
tool.DeepCopy(&sub, item)
resp.List = append(resp.List, sub)
}
return
}
internal/logic/admin/user/getUserSubscribeLogsLogic.go
+47
View File
@@ -0,0 +1,47 @@
package user
import (
"context"
"github.com/perfect-panel/ppanel-server/internal/model/user"
"github.com/perfect-panel/ppanel-server/internal/svc"
"github.com/perfect-panel/ppanel-server/internal/types"
"github.com/perfect-panel/ppanel-server/pkg/logger"
"github.com/perfect-panel/ppanel-server/pkg/tool"
"github.com/perfect-panel/ppanel-server/pkg/xerr"
"github.com/pkg/errors"
)
type GetUserSubscribeLogsLogic struct {
logger.Logger
ctx context.Context
svcCtx *svc.ServiceContext
}
// Get user subcribe logs
func NewGetUserSubscribeLogsLogic(ctx context.Context, svcCtx *svc.ServiceContext) *GetUserSubscribeLogsLogic {
return &GetUserSubscribeLogsLogic{
Logger: logger.WithContext(ctx),
ctx: ctx,
svcCtx: svcCtx,
}
}
func (l *GetUserSubscribeLogsLogic) GetUserSubscribeLogs(req *types.GetUserSubscribeLogsRequest) (resp *types.GetUserSubscribeLogsResponse, err error) {
data, total, err := l.svcCtx.UserModel.FilterSubscribeLogList(l.ctx, req.Page, req.Size, &user.SubscribeLogFilterParams{
UserSubscribeId: req.SubscribeId,
UserId: req.UserId,
})
if err != nil {
l.Errorw("[GetUserSubscribeLogs] Get User Subscribe Logs Error:", logger.Field("err", err.Error()))
return nil, errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "Get User Subscribe Logs Error")
}
var list []types.UserSubscribeLog
tool.DeepCopy(&list, data)
return &types.GetUserSubscribeLogsResponse{
List: list,
Total: total,
}, err
}
internal/logic/admin/user/getUserSubscribeTrafficLogsLogic.go
+41
View File
@@ -0,0 +1,41 @@
package user
import (
"context"
"github.com/perfect-panel/ppanel-server/pkg/tool"
"github.com/perfect-panel/ppanel-server/pkg/xerr"
"github.com/pkg/errors"
"github.com/perfect-panel/ppanel-server/internal/svc"
"github.com/perfect-panel/ppanel-server/internal/types"
"github.com/perfect-panel/ppanel-server/pkg/logger"
)
type GetUserSubscribeTrafficLogsLogic struct {
logger.Logger
ctx context.Context
svcCtx *svc.ServiceContext
}
// Get user subcribe traffic logs
func NewGetUserSubscribeTrafficLogsLogic(ctx context.Context, svcCtx *svc.ServiceContext) *GetUserSubscribeTrafficLogsLogic {
return &GetUserSubscribeTrafficLogsLogic{
Logger: logger.WithContext(ctx),
ctx: ctx,
svcCtx: svcCtx,
}
}
func (l *GetUserSubscribeTrafficLogsLogic) GetUserSubscribeTrafficLogs(req *types.GetUserSubscribeTrafficLogsRequest) (resp *types.GetUserSubscribeTrafficLogsResponse, err error) {
list, total, err := l.svcCtx.TrafficLogModel.QueryTrafficLogPageList(l.ctx, req.UserId, req.SubscribeId, req.Page, req.Size)
if err != nil {
return nil, errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "GetUserSubscribeTrafficLogs failed: %v", err.Error())
}
userRespList := make([]types.TrafficLog, 0)
tool.DeepCopy(&userRespList, list)
return &types.GetUserSubscribeTrafficLogsResponse{
Total: total,
List: userRespList,
}, nil
}
internal/logic/admin/user/kickOfflineByUserDeviceLogic.go
+42
View File
@@ -0,0 +1,42 @@
package user
import (
"context"
"github.com/perfect-panel/ppanel-server/internal/svc"
"github.com/perfect-panel/ppanel-server/internal/types"
"github.com/perfect-panel/ppanel-server/pkg/logger"
"github.com/perfect-panel/ppanel-server/pkg/xerr"
"github.com/pkg/errors"
)
type KickOfflineByUserDeviceLogic struct {
logger.Logger
ctx context.Context
svcCtx *svc.ServiceContext
}
// kick offline user device
func NewKickOfflineByUserDeviceLogic(ctx context.Context, svcCtx *svc.ServiceContext) *KickOfflineByUserDeviceLogic {
return &KickOfflineByUserDeviceLogic{
Logger: logger.WithContext(ctx),
ctx: ctx,
svcCtx: svcCtx,
}
}
func (l *KickOfflineByUserDeviceLogic) KickOfflineByUserDevice(req *types.KickOfflineRequest) error {
device, err := l.svcCtx.UserModel.FindOneDevice(l.ctx, req.Id)
if err != nil {
return errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "get Device error: %v", err.Error())
}
l.svcCtx.DeviceManager.KickDevice(device.UserId, device.Identifier)
device.Online = false
err = l.svcCtx.UserModel.UpdateDevice(l.ctx, device)
if err != nil {
l.Logger.Error("[KickOfflineByUserDeviceLogic] Update Device Error:", logger.Field("err", err.Error()))
return errors.Wrapf(xerr.NewErrCode(xerr.DatabaseUpdateError), "update Device error: %v", err.Error())
}
return nil
}
internal/logic/admin/user/updateUserAuthMethodLogic.go
+41
View File
@@ -0,0 +1,41 @@
package user
import (
"context"
"github.com/perfect-panel/ppanel-server/internal/svc"
"github.com/perfect-panel/ppanel-server/internal/types"
"github.com/perfect-panel/ppanel-server/pkg/logger"
"github.com/perfect-panel/ppanel-server/pkg/xerr"
"github.com/pkg/errors"
)
type UpdateUserAuthMethodLogic struct {
logger.Logger
ctx context.Context
svcCtx *svc.ServiceContext
}
// Update user auth method
func NewUpdateUserAuthMethodLogic(ctx context.Context, svcCtx *svc.ServiceContext) *UpdateUserAuthMethodLogic {
return &UpdateUserAuthMethodLogic{
Logger: logger.WithContext(ctx),
ctx: ctx,
svcCtx: svcCtx,
}
}
func (l *UpdateUserAuthMethodLogic) UpdateUserAuthMethod(req *types.UpdateUserAuthMethodRequest) error {
method, err := l.svcCtx.UserModel.FindUserAuthMethodByPlatform(l.ctx, req.UserId, req.AuthType)
if err != nil {
l.Errorw("Get user auth method error", logger.Field("error", err.Error()), logger.Field("userId", req.UserId), logger.Field("authType", req.AuthType))
return errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "Get user auth method error: %v", err.Error())
}
method.AuthType = req.AuthType
method.AuthIdentifier = req.AuthIdentifier
if err = l.svcCtx.UserModel.UpdateUserAuthMethods(l.ctx, method); err != nil {
l.Errorw("Update user auth method error", logger.Field("error", err.Error()), logger.Field("userId", req.UserId), logger.Field("authType", req.AuthType))
return errors.Wrapf(xerr.NewErrCode(xerr.DatabaseUpdateError), "Update user auth method error: %v", err.Error())
}
return nil
}
internal/logic/admin/user/updateUserBasicInfoLogic.go
+52
View File
@@ -0,0 +1,52 @@
package user
import (
"context"
"github.com/perfect-panel/ppanel-server/internal/svc"
"github.com/perfect-panel/ppanel-server/internal/types"
"github.com/perfect-panel/ppanel-server/pkg/logger"
"github.com/perfect-panel/ppanel-server/pkg/tool"
"github.com/perfect-panel/ppanel-server/pkg/xerr"
"github.com/pkg/errors"
)
type UpdateUserBasicInfoLogic struct {
logger.Logger
ctx context.Context
svcCtx *svc.ServiceContext
}
// NewUpdateUserBasicInfoLogic Update user basic info
func NewUpdateUserBasicInfoLogic(ctx context.Context, svcCtx *svc.ServiceContext) *UpdateUserBasicInfoLogic {
return &UpdateUserBasicInfoLogic{
Logger: logger.WithContext(ctx),
ctx: ctx,
svcCtx: svcCtx,
}
}
func (l *UpdateUserBasicInfoLogic) UpdateUserBasicInfo(req *types.UpdateUserBasiceInfoRequest) error {
userInfo, err := l.svcCtx.UserModel.FindOne(l.ctx, req.UserId)
if err != nil {
l.Errorw("[UpdateUserBasicInfoLogic] Find User Error:", logger.Field("err", err.Error()), logger.Field("userId", req.UserId))
return errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "Find User Error")
}
tool.DeepCopy(userInfo, req)
if req.Avatar != "" && !tool.IsValidImageSize(req.Avatar, 1024) {
return errors.Wrapf(xerr.NewErrCode(xerr.ERROR), "Invalid Image Size")
}
if req.Password != "" {
l.Infow("[UpdateUserBasicInfoLogic] Update User Password:", logger.Field("userId", req.UserId), logger.Field("password", req.Password))
userInfo.Password = tool.EncodePassWord(req.Password)
}
err = l.svcCtx.UserModel.Update(l.ctx, userInfo)
if err != nil {
l.Errorw("[UpdateUserBasicInfoLogic] Update User Error:", logger.Field("err", err.Error()), logger.Field("userId", req.UserId))
return errors.Wrapf(xerr.NewErrCode(xerr.DatabaseUpdateError), "Update User Error")
}
return nil
}
internal/logic/admin/user/updateUserDeviceLogic.go
+40
View File
@@ -0,0 +1,40 @@
package user
import (
"context"
"github.com/perfect-panel/ppanel-server/internal/svc"
"github.com/perfect-panel/ppanel-server/internal/types"
"github.com/perfect-panel/ppanel-server/pkg/logger"
"github.com/perfect-panel/ppanel-server/pkg/xerr"
"github.com/pkg/errors"
)
type UpdateUserDeviceLogic struct {
logger.Logger
ctx context.Context
svcCtx *svc.ServiceContext
}
// User device
func NewUpdateUserDeviceLogic(ctx context.Context, svcCtx *svc.ServiceContext) *UpdateUserDeviceLogic {
return &UpdateUserDeviceLogic{
Logger: logger.WithContext(ctx),
ctx: ctx,
svcCtx: svcCtx,
}
}
func (l *UpdateUserDeviceLogic) UpdateUserDevice(req *types.UserDevice) error {
device, err := l.svcCtx.UserModel.FindOneDevice(l.ctx, req.Id)
if err != nil {
return errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "get Device error: %v", err.Error())
}
device.Enabled = req.Enabled
err = l.svcCtx.UserModel.UpdateDevice(l.ctx, device)
if err != nil {
l.Logger.Error("[UpdateUserDeviceLogic] Update Device Error:", logger.Field("err", err.Error()))
return errors.Wrapf(xerr.NewErrCode(xerr.DatabaseUpdateError), "update Device error: %v", err.Error())
}
return nil
}
internal/logic/admin/user/updateUserNotifySettingLogic.go
+42
View File
@@ -0,0 +1,42 @@
package user
import (
"context"
"github.com/perfect-panel/ppanel-server/internal/svc"
"github.com/perfect-panel/ppanel-server/internal/types"
"github.com/perfect-panel/ppanel-server/pkg/logger"
"github.com/perfect-panel/ppanel-server/pkg/tool"
"github.com/perfect-panel/ppanel-server/pkg/xerr"
"github.com/pkg/errors"
)
type UpdateUserNotifySettingLogic struct {
logger.Logger
ctx context.Context
svcCtx *svc.ServiceContext
}
// NewUpdateUserNotifySettingLogic Update user notify setting
func NewUpdateUserNotifySettingLogic(ctx context.Context, svcCtx *svc.ServiceContext) *UpdateUserNotifySettingLogic {
return &UpdateUserNotifySettingLogic{
Logger: logger.WithContext(ctx),
ctx: ctx,
svcCtx: svcCtx,
}
}
func (l *UpdateUserNotifySettingLogic) UpdateUserNotifySetting(req *types.UpdateUserNotifySettingRequest) error {
userInfo, err := l.svcCtx.UserModel.FindOne(l.ctx, req.UserId)
if err != nil {
l.Errorw("[UpdateUserNotifySettingLogic] Find User Error:", logger.Field("err", err.Error()), logger.Field("userId", req.UserId))
return errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "Find User Error")
}
tool.DeepCopy(userInfo, req)
err = l.svcCtx.UserModel.Update(l.ctx, userInfo)
if err != nil {
l.Errorw("[UpdateUserNotifySettingLogic] Update User Error:", logger.Field("err", err.Error()), logger.Field("userId", req.UserId))
return errors.Wrapf(xerr.NewErrCode(xerr.DatabaseUpdateError), "Update User Error")
}
return nil
}
internal/logic/admin/user/updateUserSubscribeLogic.go
+57
View File
@@ -0,0 +1,57 @@
package user
import (
"context"
"time"
"github.com/perfect-panel/ppanel-server/internal/model/user"
"github.com/perfect-panel/ppanel-server/internal/svc"
"github.com/perfect-panel/ppanel-server/internal/types"
"github.com/perfect-panel/ppanel-server/pkg/logger"
"github.com/perfect-panel/ppanel-server/pkg/xerr"
"github.com/pkg/errors"
)
type UpdateUserSubscribeLogic struct {
logger.Logger
ctx context.Context
svcCtx *svc.ServiceContext
}
// NewUpdateUserSubscribeLogic Update user subscribe
func NewUpdateUserSubscribeLogic(ctx context.Context, svcCtx *svc.ServiceContext) *UpdateUserSubscribeLogic {
return &UpdateUserSubscribeLogic{
Logger: logger.WithContext(ctx),
ctx: ctx,
svcCtx: svcCtx,
}
}
func (l *UpdateUserSubscribeLogic) UpdateUserSubscribe(req *types.UpdateUserSubscribeRequest) error {
userSub, err := l.svcCtx.UserModel.FindOneUserSubscribe(l.ctx, req.UserSubscribeId)
if err != nil {
l.Errorw("FindOneUserSubscribe failed:", logger.Field("error", err.Error()), logger.Field("userSubscribeId", req.UserSubscribeId))
return errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "FindOneUserSubscribe failed: %v", err.Error())
}
err = l.svcCtx.UserModel.UpdateSubscribe(l.ctx, &user.Subscribe{
Id: req.UserSubscribeId,
UserId: userSub.UserId,
OrderId: userSub.OrderId,
SubscribeId: req.SubscribeId,
StartTime: userSub.StartTime,
ExpireTime: time.UnixMilli(req.ExpiredAt),
Traffic: req.Traffic,
Download: req.Download,
Upload: req.Upload,
Token: userSub.Token,
UUID: userSub.UUID,
Status: userSub.Status,
})
if err != nil {
l.Errorw("UpdateSubscribe failed:", logger.Field("error", err.Error()))
return errors.Wrapf(xerr.NewErrCode(xerr.DatabaseUpdateError), "UpdateSubscribe failed: %v", err.Error())
}
return nil
}