Develop (#76)
* refactor: rename queryannouncementhandler.go to queryAnnouncementLogic.go for clarity
* feat(panDomain): update subscription logic to use V2 handler for improved functionality
* refactor(subscribe): replace V2 handler with a unified Handler method for subscription logic
* feat(subscribe): implement user agent limit feature with configurable list
* fix(subscribe): improve error handling and logging for subscription requests
* feat(subscribe): add user agent limit configuration to system settings
* refactor(api): remove deprecated application-related endpoints and types
* refactor(swagger): remove deprecated app.json generation from swagger configuration
* refactor(swagger): remove deprecated app.json check from swagger configuration
* fix(subscribe): update delete method to use Where clause for improved query accuracy
* fix(subscribe): update Id field tag to use primaryKey and improve save method query
* fix(subscribe): update Id field tag to use primaryKey and improve model queries
* fix(subscribe): rename variable for clarity and add special handling for Stash user agent
* fix(email): convert RegisterStartTime and RegisterEndTime to time.Time for accurate query filtering
* refactor(log): consolidate logging models and update related logic for improved clarity and functionality
* fix(types): change Content field type in MessageLog to interface{} for improved flexibility
* fix(log): change MessageLog list to use value type for improved performance and memory efficiency
* fix(email): set EmailTypeVerify in task payload and update content type conversion for verification email
* fix(log): remove unused Id field from SystemLog during login log insertion
* fix(login): remove debug logs and error logging during user login process
* fix(log): add traffic reset logging for subscription resets
* fix(log): insert reset traffic log during subscription activation
* feat(log): add endpoints for retrieving and resetting subscribe traffic logs
* refactor(log): remove Reset Subscribe Traffic Log endpoint and related types
* feat(traffic): add traffic statistics logging and scheduling
* fix(subscribe): ensure active status and reset timestamps during traffic resets
* feat(api): enhance server and node management with new request/response structures
* refactor(api): rename OnlineUser to ServerOnlineUser for clarity
* feat(api): define OnlineUser type with SID and IP fields
* feat(server): implement server management handlers and database schema
* feat(api): add traffic log details filtering and enhance traffic log structures
* feat(api): migrate server and node data handling, update related structures and logic
* feat(server): implement server deletion logic with error handling
* feat(api): update log filtering to use ResetSubscribe type for subscription logs
* feat(api): standardize timestamp field across log structures
* feat(api): refactor cache key handling for server and user lists
* feat(api): enhance server status handling with protocol support and refactor related logic
* fix(traffic): adjust start date for traffic statistics and improve log deletion comment
* feat(api): implement daily traffic ranking for users and servers with error handling
* feat(api): update server total data response to use 'OnlineUsers' and implement daily traffic statistics logging
* feat(api): add log settings management with auto-clear and clear days configuration
* fix(log): correct category in log settings update query
* feat(routes): add handler for scheduled traffic statistics
* feat(model): add user counts struct and update queries for new and renewal users
* feat(api): add referral percentage and only first purchase fields to user model and requests
* feat(database): update user table to add referral percentage and only first purchase fields
* feat(api): add reset sort endpoints for server and node
* feat(api): add sort field to server model
* feat(api): implement sorting functionality for nodes and servers
* fix(database): add sort column to nodes table
* fix(model): enhance user statistics queries with new order and renewal order counts
* fix(log): update timestamp handling in login and registration logs
* fix(log): update sorting logic for server and user subscribe traffic logs
* fix(server): add server status handling based on last reported time
* fix(model): correct filter condition to use 'date' instead of 'data'
* fix(migration): add index for traffic log on timestamp, user_id, and subscribe_id
* fix(log): optimize user traffic rank data handling by using append instead of index assignment
* fix(filter): refactor node list creation to use append and remove duplicates from tags
* fix(node): add ServerId and Enabled fields to node update logic
* feat(tags): add endpoint to query all node tags
* fix(preview): add Preload parameter to FilterNodeList for improved data retrieval
* fix(log): date is empty
* feat(subscribe): add Language field to subscription models and update query logic
* feat(subscription): add Language parameter to GetSubscription request and update query logic
* fix(server): encode ServerKey in base64 and update last reported time for nodes
* feat: delete common GetSubscription
* feat(subscription): implement FilterList method for subscription queries and update related logic
* fix(subscribe): remove duplicate user agents in SubscribeHandler
* fix(push): initialize onlineUsers as a map in pushOnlineUsersLogic
* fix(reset): initialize subs as a map in clearCache method
* refactor(query): simplify node and tag filtering using InSet function
* feat(userlist): enhance GetServerUserListLogic with improved node and tag handling
* fix(userlist): correct node ID assignment and update query logic for tag filtering
* fix(userlist): correct node ID assignment in getServerUserListLogic
* refactor(query): streamline query construction for tag filtering
* fix(statistics): optimize server ranking data handling in QueryServerTotalDataLogic
* refactor(statistics): simplify server ranking data construction in QueryServerTotalDataLogic
* fix(statistics): correct server traffic data assignment in QueryServerTotalDataLogic
* fix(statistics): optimize yesterday's top 10 server traffic data assignment in QueryServerTotalDataLogic
* fix(middleware): remove duplicate elements from user agent list in PanDomainMiddleware
* feat(middleware): enhance user agent handling by querying client list in PanDomainMiddleware
* feat(client): subscribe_template
* feat(oauth): add user agent and IP logging to registration and login processes
* fix(balance): add timestamp to balance logs for payment, refund, and recharge transactions
* fix(log): correct comment for CommissionTypeRefund to improve clarity
* fix(log): replace magic number with constant for gift type in purchase checkout logic
* fix(log): rename OrderId to OrderNo for consistency in balance logging
* feat(log): add logging for balance, gift amount, and commission adjustments
* fix(user): correct placement of DeepCopy for user info update logic
* feat(log): add UserSubscribeId to FilterSubscribeLogRequest for enhanced filtering
* fix(purchase): streamline error handling and improve JSON marshaling for temporary orders
* fix(order): simplify commission handling and improve payload parsing logic
* fix(order): update commission calculation to actual payment amount minus gateway handling fee
* feat(payment): add support for CryptoSaaS payment platform and enhance configuration handling
* fix(balance): update QueryUserBalanceLog response structure to include balance log list
* fix(email): update task progress handling to use specific task ID for updates
* feat(quota): add quota task creation and querying endpoints with updated data structures
* fix(email): update task handling to use generic task model and improve error logging
* fix(order): improve error logging for database transaction and user cache updates
* feat(quota): enhance quota task management with new request structures and processing logic
* fix(quota): remove redundant quota task status endpoint from admin marketing routes
* fix(worker): update task completion status handling in worker logic
* fix(quota): update taskInfo to include current subscription count in quota logic
* doc(log): rename function for clarity and add cache cleanup comment
* fix(quota): update time handling in quota logic and correct subscriber ID query
* fix(quota): update time handling to use UnixMilli for start time in quota logic
* feat(protocol): add server protocol configuration query and enhance protocol options
* fix(quota): correct time range queries for start and expire times in quota logic
* fix(types): update plugin options to include 'none' in the plugin field
---------
Co-authored-by: Chang lue Tsen <tension@ppanel.dev>
This commit is contained in:
Leif Draven
@@ -6,12 +6,10 @@ import (
|
||||
"strings"
|
||||
"time"
|
||||
|
||||
"github.com/perfect-panel/server/pkg/adapter"
|
||||
"github.com/perfect-panel/server/pkg/adapter/shadowrocket"
|
||||
"github.com/perfect-panel/server/pkg/adapter/surfboard"
|
||||
"github.com/perfect-panel/server/pkg/adapter/surge"
|
||||
|
||||
"github.com/perfect-panel/server/internal/model/server"
|
||||
"github.com/perfect-panel/server/adapter"
|
||||
"github.com/perfect-panel/server/internal/model/client"
|
||||
"github.com/perfect-panel/server/internal/model/log"
|
||||
"github.com/perfect-panel/server/internal/model/node"
|
||||
|
||||
"github.com/perfect-panel/server/internal/model/user"
|
||||
|
||||
@@ -39,37 +37,123 @@ func NewSubscribeLogic(ctx *gin.Context, svc *svc.ServiceContext) *SubscribeLogi
|
||||
}
|
||||
}
|
||||
|
||||
func (l *SubscribeLogic) Generate(req *types.SubscribeRequest) (*types.SubscribeResponse, error) {
|
||||
userSub, err := l.getUserSubscribe(req.Token)
|
||||
func (l *SubscribeLogic) Handler(req *types.SubscribeRequest) (resp *types.SubscribeResponse, err error) {
|
||||
// query client list
|
||||
clients, err := l.svc.ClientModel.List(l.ctx.Request.Context())
|
||||
if err != nil {
|
||||
l.Errorw("[SubscribeLogic] Query client list failed", logger.Field("error", err.Error()))
|
||||
return nil, err
|
||||
}
|
||||
|
||||
userAgent := strings.ToLower(l.ctx.Request.UserAgent())
|
||||
|
||||
var targetApp, defaultApp *client.SubscribeApplication
|
||||
|
||||
for _, item := range clients {
|
||||
u := strings.ToLower(item.UserAgent)
|
||||
if item.IsDefault {
|
||||
defaultApp = item
|
||||
}
|
||||
|
||||
if strings.Contains(userAgent, u) {
|
||||
// Special handling for Stash
|
||||
if strings.Contains(userAgent, "stash") && !strings.Contains(u, "stash") {
|
||||
continue
|
||||
}
|
||||
targetApp = item
|
||||
break
|
||||
}
|
||||
}
|
||||
if targetApp == nil {
|
||||
l.Debugf("[SubscribeLogic] No matching client found", logger.Field("userAgent", userAgent))
|
||||
if defaultApp == nil {
|
||||
return nil, errors.Wrapf(xerr.NewErrCode(xerr.ERROR), "No matching client found for user agent: %s", userAgent)
|
||||
}
|
||||
targetApp = defaultApp
|
||||
}
|
||||
// Find user subscribe by token
|
||||
userSubscribe, err := l.getUserSubscribe(req.Token)
|
||||
if err != nil {
|
||||
l.Errorw("[SubscribeLogic] Get user subscribe failed", logger.Field("error", err.Error()), logger.Field("token", req.Token))
|
||||
return nil, err
|
||||
}
|
||||
|
||||
var subscribeStatus = false
|
||||
defer func() {
|
||||
l.logSubscribeActivity(subscribeStatus, userSub, req)
|
||||
l.logSubscribeActivity(subscribeStatus, userSubscribe, req)
|
||||
}()
|
||||
// find subscribe info
|
||||
subscribeInfo, err := l.svc.SubscribeModel.FindOne(l.ctx.Request.Context(), userSubscribe.SubscribeId)
|
||||
if err != nil {
|
||||
l.Errorw("[SubscribeLogic] Find subscribe info failed", logger.Field("error", err.Error()), logger.Field("subscribeId", userSubscribe.SubscribeId))
|
||||
return nil, errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "Find subscribe info failed: %v", err.Error())
|
||||
}
|
||||
|
||||
servers, err := l.getServers(userSub)
|
||||
// Find server list by user subscribe
|
||||
servers, err := l.getServers(userSubscribe)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
a := adapter.NewAdapter(
|
||||
targetApp.SubscribeTemplate,
|
||||
adapter.WithServers(servers),
|
||||
adapter.WithSiteName(l.svc.Config.Site.SiteName),
|
||||
adapter.WithSubscribeName(subscribeInfo.Name),
|
||||
adapter.WithOutputFormat(targetApp.OutputFormat),
|
||||
adapter.WithUserInfo(adapter.User{
|
||||
Password: userSubscribe.UUID,
|
||||
ExpiredAt: userSubscribe.ExpireTime,
|
||||
Download: userSubscribe.Download,
|
||||
Upload: userSubscribe.Upload,
|
||||
Traffic: userSubscribe.Traffic,
|
||||
SubscribeURL: l.getSubscribeV2URL(req.Token),
|
||||
}),
|
||||
)
|
||||
|
||||
rules, err := l.getRules()
|
||||
// Get client config
|
||||
adapterClient, err := a.Client()
|
||||
if err != nil {
|
||||
return nil, err
|
||||
l.Errorw("[SubscribeLogic] Client error", logger.Field("error", err.Error()))
|
||||
return nil, errors.Wrapf(xerr.NewErrCode(500), "Client error: %v", err.Error())
|
||||
}
|
||||
bytes, err := adapterClient.Build()
|
||||
if err != nil {
|
||||
l.Errorw("[SubscribeLogic] Build client config failed", logger.Field("error", err.Error()))
|
||||
return nil, errors.Wrapf(xerr.NewErrCode(500), "Build client config failed: %v", err.Error())
|
||||
}
|
||||
|
||||
resp, headerInfo, err := l.buildClientConfig(req, userSub, servers, rules)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
var formats = []string{"json", "yaml", "conf"}
|
||||
|
||||
for _, format := range formats {
|
||||
if format == strings.ToLower(targetApp.OutputFormat) {
|
||||
l.ctx.Header("content-disposition", fmt.Sprintf("attachment;filename*=UTF-8''%s.%s", url.QueryEscape(l.svc.Config.Site.SiteName), format))
|
||||
l.ctx.Header("Content-Type", "application/octet-stream; charset=UTF-8")
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
resp = &types.SubscribeResponse{
|
||||
Config: bytes,
|
||||
Header: fmt.Sprintf(
|
||||
"upload=%d;download=%d;total=%d;expire=%d",
|
||||
userSubscribe.Upload, userSubscribe.Download, userSubscribe.Traffic, userSubscribe.ExpireTime.Unix(),
|
||||
),
|
||||
}
|
||||
subscribeStatus = true
|
||||
return &types.SubscribeResponse{
|
||||
Config: resp,
|
||||
Header: headerInfo,
|
||||
}, nil
|
||||
return
|
||||
}
|
||||
|
||||
func (l *SubscribeLogic) getSubscribeV2URL(token string) string {
|
||||
if l.svc.Config.Subscribe.PanDomain {
|
||||
return fmt.Sprintf("https://%s", l.ctx.Request.Host)
|
||||
}
|
||||
|
||||
if l.svc.Config.Subscribe.SubscribeDomain != "" {
|
||||
domains := strings.Split(l.svc.Config.Subscribe.SubscribeDomain, "\n")
|
||||
return fmt.Sprintf("https://%s%s?token=%s", domains[0], l.svc.Config.Subscribe.SubscribePath, token)
|
||||
}
|
||||
|
||||
return fmt.Sprintf("https://%s%s?token=%s&", l.ctx.Request.Host, l.svc.Config.Subscribe.SubscribePath, token)
|
||||
}
|
||||
|
||||
func (l *SubscribeLogic) getUserSubscribe(token string) (*user.Subscribe, error) {
|
||||
@@ -92,19 +176,27 @@ func (l *SubscribeLogic) logSubscribeActivity(subscribeStatus bool, userSub *use
|
||||
return
|
||||
}
|
||||
|
||||
err := l.svc.UserModel.InsertSubscribeLog(l.ctx.Request.Context(), &user.SubscribeLog{
|
||||
UserId: userSub.UserId,
|
||||
UserSubscribeId: userSub.Id,
|
||||
subscribeLog := log.Subscribe{
|
||||
Token: req.Token,
|
||||
IP: l.ctx.ClientIP(),
|
||||
UserAgent: l.ctx.Request.UserAgent(),
|
||||
UserAgent: req.UA,
|
||||
ClientIP: l.ctx.ClientIP(),
|
||||
UserSubscribeId: userSub.Id,
|
||||
}
|
||||
|
||||
content, _ := subscribeLog.Marshal()
|
||||
|
||||
err := l.svc.LogModel.Insert(l.ctx.Request.Context(), &log.SystemLog{
|
||||
Type: log.TypeSubscribe.Uint8(),
|
||||
ObjectID: userSub.UserId, // log user id
|
||||
Date: time.Now().Format(time.DateOnly),
|
||||
Content: string(content),
|
||||
})
|
||||
if err != nil {
|
||||
l.Errorw("[Generate Subscribe]insert subscribe log error: %v", logger.Field("error", err.Error()))
|
||||
}
|
||||
}
|
||||
|
||||
func (l *SubscribeLogic) getServers(userSub *user.Subscribe) ([]*server.Server, error) {
|
||||
func (l *SubscribeLogic) getServers(userSub *user.Subscribe) ([]*node.Node, error) {
|
||||
if l.isSubscriptionExpired(userSub) {
|
||||
return l.createExpiredServers(), nil
|
||||
}
|
||||
@@ -115,49 +207,61 @@ func (l *SubscribeLogic) getServers(userSub *user.Subscribe) ([]*server.Server,
|
||||
return nil, errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "find subscribe details error: %v", err.Error())
|
||||
}
|
||||
|
||||
serverIds := tool.StringToInt64Slice(subDetails.Server)
|
||||
groupIds := tool.StringToInt64Slice(subDetails.ServerGroup)
|
||||
nodeIds := tool.StringToInt64Slice(subDetails.Nodes)
|
||||
tags := strings.Split(subDetails.NodeTags, ",")
|
||||
|
||||
l.Debugf("[Generate Subscribe]serverIds: %v, groupIds: %v", serverIds, groupIds)
|
||||
l.Debugf("[Generate Subscribe]nodes: %v, NodeTags: %v", nodeIds, tags)
|
||||
|
||||
servers, err := l.svc.ServerModel.FindServerDetailByGroupIdsAndIds(l.ctx.Request.Context(), groupIds, serverIds)
|
||||
_, nodes, err := l.svc.NodeModel.FilterNodeList(l.ctx.Request.Context(), &node.FilterNodeParams{
|
||||
Page: 1,
|
||||
Size: 1000,
|
||||
ServerId: nodeIds,
|
||||
Tag: tool.RemoveDuplicateElements(tags...),
|
||||
Preload: true,
|
||||
})
|
||||
|
||||
l.Debugf("[Query Subscribe]found servers: %v", len(servers))
|
||||
l.Debugf("[Query Subscribe]found servers: %v", len(nodes))
|
||||
|
||||
if err != nil {
|
||||
l.Errorw("[Generate Subscribe]find server details error: %v", logger.Field("error", err.Error()))
|
||||
return nil, errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "find server details error: %v", err.Error())
|
||||
}
|
||||
logger.Debugf("[Generate Subscribe]found servers: %v", len(servers))
|
||||
return servers, nil
|
||||
logger.Debugf("[Generate Subscribe]found servers: %v", len(nodes))
|
||||
return nodes, nil
|
||||
}
|
||||
|
||||
func (l *SubscribeLogic) isSubscriptionExpired(userSub *user.Subscribe) bool {
|
||||
return userSub.ExpireTime.Unix() < time.Now().Unix() && userSub.ExpireTime.Unix() != 0
|
||||
}
|
||||
|
||||
func (l *SubscribeLogic) createExpiredServers() []*server.Server {
|
||||
func (l *SubscribeLogic) createExpiredServers() []*node.Node {
|
||||
enable := true
|
||||
host := l.getFirstHostLine()
|
||||
|
||||
return []*server.Server{
|
||||
return []*node.Node{
|
||||
{
|
||||
Name: "Subscribe Expired",
|
||||
ServerAddr: "127.0.0.1",
|
||||
RelayMode: "none",
|
||||
Protocol: "shadowsocks",
|
||||
Config: "{\"method\":\"aes-256-gcm\",\"port\":1}",
|
||||
Enable: &enable,
|
||||
Sort: 0,
|
||||
Name: "Subscribe Expired",
|
||||
Tags: "",
|
||||
Port: 18080,
|
||||
Address: "127.0.0.1",
|
||||
Server: &node.Server{
|
||||
Name: "Subscribe Expired",
|
||||
Protocols: "[{\"type:\"\"shadowsocks\",\"cipher\":\"aes-256-gcm\",\"port\":1}]",
|
||||
},
|
||||
Protocol: "shadowsocks",
|
||||
Enabled: &enable,
|
||||
},
|
||||
{
|
||||
Name: host,
|
||||
ServerAddr: "127.0.0.1",
|
||||
RelayMode: "none",
|
||||
Protocol: "shadowsocks",
|
||||
Config: "{\"method\":\"aes-256-gcm\",\"port\":1}",
|
||||
Enable: &enable,
|
||||
Sort: 0,
|
||||
Name: host,
|
||||
Tags: "",
|
||||
Port: 18080,
|
||||
Address: "127.0.0.1",
|
||||
Server: &node.Server{
|
||||
Name: "Subscribe Expired",
|
||||
Protocols: "[{\"type:\"\"shadowsocks\",\"cipher\":\"aes-256-gcm\",\"port\":1}]",
|
||||
},
|
||||
Protocol: "shadowsocks",
|
||||
Enabled: &enable,
|
||||
},
|
||||
}
|
||||
}
|
||||
@@ -170,175 +274,3 @@ func (l *SubscribeLogic) getFirstHostLine() string {
|
||||
}
|
||||
return host
|
||||
}
|
||||
|
||||
func (l *SubscribeLogic) getRules() ([]*server.RuleGroup, error) {
|
||||
rules, err := l.svc.ServerModel.QueryAllRuleGroup(l.ctx)
|
||||
if err != nil {
|
||||
l.Errorw("[Generate Subscribe]find rule group error: %v", logger.Field("error", err.Error()))
|
||||
return nil, errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "find rule group error: %v", err.Error())
|
||||
}
|
||||
return rules, nil
|
||||
}
|
||||
|
||||
func (l *SubscribeLogic) buildClientConfig(req *types.SubscribeRequest, userSub *user.Subscribe, servers []*server.Server, rules []*server.RuleGroup) ([]byte, string, error) {
|
||||
tags := make(map[string][]*server.Server)
|
||||
|
||||
serverTags, err := l.svc.ServerModel.FindServerTags(l.ctx)
|
||||
if err != nil {
|
||||
l.Errorw("[Generate Subscribe]find server tags error: %v", logger.Field("error", err.Error()))
|
||||
return nil, "", errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "find server tags error: %v", err.Error())
|
||||
}
|
||||
// Deduplicate tags
|
||||
serverTags = tool.RemoveDuplicateElements(serverTags...)
|
||||
for _, tag := range serverTags {
|
||||
s, err := l.svc.ServerModel.FindServersByTag(l.ctx.Request.Context(), tag)
|
||||
if err != nil {
|
||||
l.Errorw("[Generate Subscribe]find servers by tag error: %v", logger.Field("error", err.Error()))
|
||||
continue
|
||||
}
|
||||
if len(s) > 0 {
|
||||
tags[tag] = s
|
||||
}
|
||||
}
|
||||
|
||||
proxyManager := adapter.NewAdapter(&adapter.Config{
|
||||
Nodes: servers,
|
||||
Rules: rules,
|
||||
Tags: tags,
|
||||
})
|
||||
clientType := l.getClientType(req)
|
||||
var resp []byte
|
||||
|
||||
l.Logger.Info(fmt.Sprintf("[Generate Subscribe] %s", clientType), logger.Field("ua", req.UA), logger.Field("flag", req.Flag))
|
||||
|
||||
switch clientType {
|
||||
case "clash":
|
||||
resp, err = proxyManager.BuildClash(userSub.UUID)
|
||||
if err != nil {
|
||||
l.Errorw("[Generate Subscribe] build clash error", logger.Field("error", err.Error()))
|
||||
return nil, "", errors.Wrapf(xerr.NewErrCode(xerr.ERROR), "build clash error: %v", err.Error())
|
||||
}
|
||||
l.setClashHeaders()
|
||||
case "sing-box":
|
||||
resp, err = proxyManager.BuildSingbox(userSub.UUID)
|
||||
if err != nil {
|
||||
l.Errorw("[Generate Subscribe] build sing-box error", logger.Field("error", err.Error()))
|
||||
return nil, "", errors.Wrapf(xerr.NewErrCode(xerr.ERROR), "build sing-box error: %v", err.Error())
|
||||
}
|
||||
case "quantumult":
|
||||
resp = []byte(proxyManager.BuildQuantumultX(userSub.UUID))
|
||||
case "shadowrocket":
|
||||
resp = proxyManager.BuildShadowrocket(userSub.UUID, shadowrocket.UserInfo{
|
||||
Upload: userSub.Upload,
|
||||
Download: userSub.Download,
|
||||
TotalTraffic: userSub.Traffic,
|
||||
ExpiredDate: userSub.ExpireTime,
|
||||
})
|
||||
case "loon":
|
||||
resp = proxyManager.BuildLoon(userSub.UUID)
|
||||
l.setLoonHeaders()
|
||||
case "surfboard":
|
||||
subsURL := l.getSubscribeURL(userSub.Token, "surfboard")
|
||||
resp = proxyManager.BuildSurfboard(l.svc.Config.Site.SiteName, surfboard.UserInfo{
|
||||
Upload: userSub.Upload,
|
||||
Download: userSub.Download,
|
||||
TotalTraffic: userSub.Traffic,
|
||||
ExpiredDate: userSub.ExpireTime,
|
||||
UUID: userSub.UUID,
|
||||
SubscribeURL: subsURL,
|
||||
})
|
||||
l.setSurfboardHeaders()
|
||||
case "v2rayn":
|
||||
resp = proxyManager.BuildV2rayN(userSub.UUID)
|
||||
case "surge":
|
||||
subsURL := l.getSubscribeURL(userSub.Token, "surge")
|
||||
resp = proxyManager.BuildSurge(l.svc.Config.Site.SiteName, surge.UserInfo{
|
||||
UUID: userSub.UUID,
|
||||
Upload: userSub.Upload,
|
||||
Download: userSub.Download,
|
||||
TotalTraffic: userSub.Traffic,
|
||||
ExpiredDate: userSub.ExpireTime,
|
||||
SubscribeURL: subsURL,
|
||||
})
|
||||
l.setSurgeHeaders()
|
||||
default:
|
||||
resp = proxyManager.BuildGeneral(userSub.UUID)
|
||||
}
|
||||
|
||||
headerInfo := fmt.Sprintf("upload=%d;download=%d;total=%d;expire=%d",
|
||||
userSub.Upload, userSub.Download, userSub.Traffic, userSub.ExpireTime.Unix())
|
||||
|
||||
return resp, headerInfo, nil
|
||||
}
|
||||
|
||||
func (l *SubscribeLogic) setClashHeaders() {
|
||||
l.ctx.Header("content-disposition", fmt.Sprintf("attachment;filename*=UTF-8''%s", url.QueryEscape(l.svc.Config.Site.SiteName)))
|
||||
l.ctx.Header("Profile-Update-Interval", "24")
|
||||
l.ctx.Header("Content-Type", "application/octet-stream; charset=UTF-8")
|
||||
}
|
||||
|
||||
func (l *SubscribeLogic) setSurfboardHeaders() {
|
||||
l.ctx.Header("content-disposition", fmt.Sprintf("attachment;filename*=UTF-8''%s.conf", url.QueryEscape(l.svc.Config.Site.SiteName)))
|
||||
l.ctx.Header("Content-Type", "application/octet-stream; charset=UTF-8")
|
||||
}
|
||||
|
||||
func (l *SubscribeLogic) setSurgeHeaders() {
|
||||
l.ctx.Header("content-disposition", fmt.Sprintf("attachment;filename*=UTF-8''%s.conf", url.QueryEscape(l.svc.Config.Site.SiteName)))
|
||||
l.ctx.Header("Content-Type", "application/octet-stream; charset=UTF-8")
|
||||
}
|
||||
|
||||
func (l *SubscribeLogic) setLoonHeaders() {
|
||||
l.ctx.Header("content-disposition", fmt.Sprintf("attachment;filename*=UTF-8''%s.conf", url.QueryEscape(l.svc.Config.Site.SiteName)))
|
||||
l.ctx.Header("Content-Type", "application/octet-stream; charset=UTF-8")
|
||||
}
|
||||
|
||||
func (l *SubscribeLogic) getSubscribeURL(token, flag string) string {
|
||||
if l.svc.Config.Subscribe.PanDomain {
|
||||
return fmt.Sprintf("https://%s", l.ctx.Request.Host)
|
||||
}
|
||||
|
||||
if l.svc.Config.Subscribe.SubscribeDomain != "" {
|
||||
domains := strings.Split(l.svc.Config.Subscribe.SubscribeDomain, "\n")
|
||||
return fmt.Sprintf("https://%s%s?token=%s&flag=%s", domains[0], l.svc.Config.Subscribe.SubscribePath, token, flag)
|
||||
}
|
||||
|
||||
return fmt.Sprintf("https://%s%s?token=%s&flag=surfboard", l.ctx.Request.Host, l.svc.Config.Subscribe.SubscribePath, token)
|
||||
}
|
||||
|
||||
func (l *SubscribeLogic) getClientType(req *types.SubscribeRequest) string {
|
||||
clientTypeMap := map[string]string{
|
||||
"clash": "clash",
|
||||
"meta": "clash",
|
||||
"sing-box": "sing-box",
|
||||
"hiddify": "sing-box",
|
||||
"surge": "surge",
|
||||
"quantumult": "quantumult",
|
||||
"shadowrocket": "shadowrocket",
|
||||
"loon": "loon",
|
||||
"surfboard": "surfboard",
|
||||
"v2rayn": "v2rayn",
|
||||
}
|
||||
|
||||
findClient := func(s string) string {
|
||||
s = strings.ToLower(strings.TrimSpace(s))
|
||||
if s == "" {
|
||||
return ""
|
||||
}
|
||||
|
||||
for key, clientType := range clientTypeMap {
|
||||
if strings.Contains(s, key) {
|
||||
return clientType
|
||||
}
|
||||
}
|
||||
|
||||
return ""
|
||||
}
|
||||
|
||||
// 优先检查Flag参数
|
||||
if typ := findClient(req.Flag); typ != "" {
|
||||
return typ
|
||||
}
|
||||
|
||||
// 其次检查UA参数
|
||||
return findClient(req.UA)
|
||||
}
|
||||
|
||||
@@ -1,127 +0,0 @@
|
||||
package subscribe
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"net/url"
|
||||
"strings"
|
||||
|
||||
"github.com/perfect-panel/server/adapter"
|
||||
"github.com/perfect-panel/server/internal/model/client"
|
||||
"github.com/perfect-panel/server/internal/types"
|
||||
"github.com/perfect-panel/server/pkg/logger"
|
||||
"github.com/perfect-panel/server/pkg/xerr"
|
||||
"github.com/pkg/errors"
|
||||
)
|
||||
|
||||
func (l *SubscribeLogic) V2(req *types.SubscribeRequest) (resp *types.SubscribeResponse, err error) {
|
||||
// query client list
|
||||
clients, err := l.svc.ClientModel.List(l.ctx.Request.Context())
|
||||
if err != nil {
|
||||
l.Errorw("[SubscribeLogic] Query client list failed", logger.Field("error", err.Error()))
|
||||
return nil, err
|
||||
}
|
||||
|
||||
userAgent := strings.ToLower(l.ctx.Request.UserAgent())
|
||||
|
||||
var targetApp, defaultApp *client.SubscribeApplication
|
||||
|
||||
for _, item := range clients {
|
||||
u := strings.ToLower(item.UserAgent)
|
||||
if item.IsDefault {
|
||||
defaultApp = item
|
||||
}
|
||||
if strings.Contains(userAgent, u) {
|
||||
targetApp = item
|
||||
break
|
||||
}
|
||||
}
|
||||
if targetApp == nil {
|
||||
l.Debugf("[SubscribeLogic] No matching client found", logger.Field("userAgent", userAgent))
|
||||
if defaultApp == nil {
|
||||
return nil, errors.Wrapf(xerr.NewErrCode(xerr.ERROR), "No matching client found for user agent: %s", userAgent)
|
||||
}
|
||||
targetApp = defaultApp
|
||||
}
|
||||
// Find user subscribe by token
|
||||
userSubscribe, err := l.getUserSubscribe(req.Token)
|
||||
if err != nil {
|
||||
l.Errorw("[SubscribeLogic] Get user subscribe failed", logger.Field("error", err.Error()), logger.Field("token", req.Token))
|
||||
return nil, err
|
||||
}
|
||||
|
||||
var subscribeStatus = false
|
||||
defer func() {
|
||||
l.logSubscribeActivity(subscribeStatus, userSubscribe, req)
|
||||
}()
|
||||
// find subscribe info
|
||||
subscribeInfo, err := l.svc.SubscribeModel.FindOne(l.ctx.Request.Context(), userSubscribe.SubscribeId)
|
||||
if err != nil {
|
||||
l.Errorw("[SubscribeLogic] Find subscribe info failed", logger.Field("error", err.Error()), logger.Field("subscribeId", userSubscribe.SubscribeId))
|
||||
return nil, errors.Wrapf(xerr.NewErrCode(xerr.DatabaseQueryError), "Find subscribe info failed: %v", err.Error())
|
||||
}
|
||||
|
||||
// Find server list by user subscribe
|
||||
servers, err := l.getServers(userSubscribe)
|
||||
if err != nil {
|
||||
return nil, err
|
||||
}
|
||||
a := adapter.NewAdapter(
|
||||
targetApp.SubscribeTemplate,
|
||||
adapter.WithServers(servers),
|
||||
adapter.WithSiteName(l.svc.Config.Site.SiteName),
|
||||
adapter.WithSubscribeName(subscribeInfo.Name),
|
||||
adapter.WithOutputFormat(targetApp.OutputFormat),
|
||||
adapter.WithUserInfo(adapter.User{
|
||||
Password: userSubscribe.UUID,
|
||||
ExpiredAt: userSubscribe.ExpireTime,
|
||||
Download: userSubscribe.Download,
|
||||
Upload: userSubscribe.Upload,
|
||||
Traffic: userSubscribe.Traffic,
|
||||
SubscribeURL: l.getSubscribeV2URL(req.Token),
|
||||
}),
|
||||
)
|
||||
|
||||
// Get client config
|
||||
adapterClient, err := a.Client()
|
||||
if err != nil {
|
||||
l.Errorw("[SubscribeLogic] Client error", logger.Field("error", err.Error()))
|
||||
return nil, errors.Wrapf(xerr.NewErrCode(500), "Client error: %v", err.Error())
|
||||
}
|
||||
bytes, err := adapterClient.Build()
|
||||
if err != nil {
|
||||
l.Errorw("[SubscribeLogic] Build client config failed", logger.Field("error", err.Error()))
|
||||
return nil, errors.Wrapf(xerr.NewErrCode(500), "Build client config failed: %v", err.Error())
|
||||
}
|
||||
|
||||
var formats = []string{"json", "yaml", "conf"}
|
||||
|
||||
for _, format := range formats {
|
||||
if format == strings.ToLower(targetApp.OutputFormat) {
|
||||
l.ctx.Header("content-disposition", fmt.Sprintf("attachment;filename*=UTF-8''%s.%s", url.QueryEscape(l.svc.Config.Site.SiteName), format))
|
||||
l.ctx.Header("Content-Type", "application/octet-stream; charset=UTF-8")
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
resp = &types.SubscribeResponse{
|
||||
Config: bytes,
|
||||
Header: fmt.Sprintf(
|
||||
"upload=%d;download=%d;total=%d;expire=%d",
|
||||
userSubscribe.Upload, userSubscribe.Download, userSubscribe.Traffic, userSubscribe.ExpireTime.Unix(),
|
||||
),
|
||||
}
|
||||
return
|
||||
}
|
||||
|
||||
func (l *SubscribeLogic) getSubscribeV2URL(token string) string {
|
||||
if l.svc.Config.Subscribe.PanDomain {
|
||||
return fmt.Sprintf("https://%s", l.ctx.Request.Host)
|
||||
}
|
||||
|
||||
if l.svc.Config.Subscribe.SubscribeDomain != "" {
|
||||
domains := strings.Split(l.svc.Config.Subscribe.SubscribeDomain, "\n")
|
||||
return fmt.Sprintf("https://%s%s?token=%s", domains[0], l.svc.Config.Subscribe.SubscribePath, token)
|
||||
}
|
||||
|
||||
return fmt.Sprintf("https://%s%s?token=%s&", l.ctx.Request.Host, l.svc.Config.Subscribe.SubscribePath, token)
|
||||
}
|
||||
Reference in New Issue
Block a user