buyfakett/HomeDash-Backend
1
0
Fork 0
mirror of https://github.com/hamster1963/HomeDash-Backend.git synced 2025-06-19 21:51:21 +08:00
Code Issues Packages Projects Releases Wiki Activity

update: 初始化代码提交

Browse Source
This commit is contained in:
hamster1963
2023-10-03 15:57:52 +08:00
commit 98a96392fa
46 changed files with 2429 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

68
utility/network_utils/coffee.go Normal file
View File

@ -0,0 +1,68 @@
package network_utils
import (
"context"
"fmt"
"github.com/gogf/gf/v2/encoding/gjson"
"github.com/gogf/gf/v2/frame/g"
"github.com/gogf/gf/v2/net/gclient"
"github.com/gogf/gf/v2/os/gcache"
"github.com/gogf/gf/v2/util/gconv"
"home-network-watcher/manifest"
)
type uProxyProvider struct{}
var ProxyProvider = &uProxyProvider{}
// GetSubscribeInfo
//
// @dc: 获取订阅信息
// @author: laixin @date:2023/6/6 04:15:01
func (u *uProxyProvider) GetSubscribeInfo() (err error) {
err, authData := getAuthData()
if err != nil || authData == "" {
return
}
proxyClient := gclient.New()
proxyClient.SetHeaderMap(map[string]string{
"Authorization": authData,
})
response, err := proxyClient.Get(context.TODO(), manifest.ProxyProviderBaseUrl, nil)
if err != nil {
return
}
infoData := gconv.Map(gconv.Map(response.ReadAllString())["data"])
if infoData["d"] == nil || infoData["transfer_enable"] == nil {
return
}
usedBound := gconv.Float64(infoData["d"]) / 1024 / 1024 / 1010
planBound := gconv.Float64(infoData["transfer_enable"]) / 1024 / 1024 / 1024
remainBound := planBound - usedBound
// 保留两位小数
usedBoundStr := fmt.Sprintf("%.2f", usedBound)
planBoundStr := fmt.Sprintf("%.2f", planBound)
remainBoundStr := fmt.Sprintf("%.2f", remainBound)
proxyCache := g.Map{
"usedBound": usedBoundStr,
"planBound": planBoundStr,
"remainBound": remainBoundStr,
}
err = gcache.Set(context.TODO(), manifest.ProxySubscribeCacheKey, proxyCache, 0)
if err != nil {
return err
}
return
}
// getAuthData
//
// @dc: 获取代理提供商AuthData
func getAuthData() (err error, authData string) {
url := manifest.ProxyProviderLoginUrl
response, err := gclient.New().Post(context.TODO(), url, manifest.ProxyProviderAuthData)
if err != nil {
return
}
return nil, gjson.New(response.ReadAllString()).Get("data.auth_data").String()
}

94
utility/network_utils/home_network.go Normal file
View File

@ -0,0 +1,94 @@
package network_utils
import (
"context"
"fmt"
"github.com/gogf/gf/v2/encoding/gjson"
"github.com/gogf/gf/v2/frame/g"
"github.com/gogf/gf/v2/os/gcache"
"github.com/gogf/gf/v2/os/gtime"
"github.com/gogf/gf/v2/util/gconv"
"github.com/hamster1963/360-router-data-retriever/rconfig"
"github.com/hamster1963/360-router-data-retriever/rutils"
"home-network-watcher/manifest"
"time"
)
type uNetworkUtils struct {
}
var NetworkUtils = &uNetworkUtils{}
var (
routerConfig = &rconfig.RouterConfig{
RouterIP: manifest.HomeNetworkRouterIP,
RouterAddress: manifest.HomeNetworkRouterAddress,
RouterPassword: manifest.HomeNetworkRouterPassword,
}
routerMain rutils.SRouterController = rutils.NewRouter().InitRouter(routerConfig)
)
// GetHomeNetwork
//
// @dc: 获取家庭路由器网速
// @author: laixin @date:2023/4/2 19:43:13
func (u *uNetworkUtils) GetHomeNetwork() (err error) {
var (
homeNetwork = g.Map{
"time": "",
"rxSpeedKbps": 0,
"txSpeedKbps": 0,
"rxSpeedMbps": 0,
"txSpeedMbps": 0,
}
)
// 检测登陆状态
if login, err := routerMain.CheckLogin(); err != nil || login == false {
err := routerMain.GetRandomString()
if err != nil {
return err
}
err = routerMain.GenerateAesString()
if err != nil {
return err
}
err = routerMain.Login()
if err != nil {
return err
}
}
routerSpeedInfo, err := routerMain.GetRouterSpeed()
if err != nil {
return err
}
jsonData := gjson.New(routerSpeedInfo)
rxSpeed := jsonData.Get("data.down_speed") // 下载速度
txSpeed := jsonData.Get("data.up_speed") // 上传速度
// 速度单位转换
rxSpeedKbps := gconv.Float64(fmt.Sprintf("%.2f", gconv.Float64(rxSpeed)/1024))
txSpeedKbps := gconv.Float64(fmt.Sprintf("%.2f", gconv.Float64(txSpeed)/1024))
homeNetwork["rxSpeedKbps"] = rxSpeedKbps
homeNetwork["txSpeedKbps"] = txSpeedKbps
// 转换成MB
rxSpeedMbps := gconv.Float64(fmt.Sprintf("%.2f", gconv.Float64(rxSpeed)/1024/1024))
txSpeedMbps := gconv.Float64(fmt.Sprintf("%.2f", gconv.Float64(txSpeed)/1024/1024))
homeNetwork["rxSpeedMbps"] = rxSpeedMbps
homeNetwork["txSpeedMbps"] = txSpeedMbps
homeNetwork["time"] = gtime.Now().String()
deviceData, err := routerMain.GetDeviceList()
if err != nil {
return err
}
homeNetwork["deviceCount"] = len(gjson.New(deviceData).Get("client_node").Array())
err = gcache.Set(context.Background(), manifest.HomeNetworkCacheKey, homeNetwork, 10*time.Second)
if err != nil {
return err
}
return nil
}

129
utility/network_utils/node_utils.go Normal file
View File

@ -0,0 +1,129 @@
package network_utils
import (
"context"
"crypto/tls"
"github.com/gogf/gf/v2/encoding/gjson"
"github.com/gogf/gf/v2/errors/gerror"
"github.com/gogf/gf/v2/frame/g"
"github.com/gogf/gf/v2/net/gclient"
"github.com/gogf/gf/v2/os/gcache"
"github.com/gogf/gf/v2/os/glog"
"github.com/gogf/gf/v2/os/gtime"
"github.com/gogf/gf/v2/util/gconv"
"home-network-watcher/manifest"
"net/http"
"time"
)
type uNodeUtils struct{}
var NodeUtils = &uNodeUtils{}
// GetNodeInfo
//
// @dc: 获取节点信息
// @author: laixin @date:2023/4/2 20:08:50
func (u *uNodeUtils) GetNodeInfo() (err error) {
var (
connectedNode string
lastChangeTime string
nodeInfo = g.Map{
"nodeName": "",
"lastChangeTime": "",
"updateTime": "",
}
)
// 获取token
token, err := u.GetToken()
if err != nil {
return err
}
wsUrl := "ws://" + manifest.XrayBaseUrl + "/api/message?Authorization=" + token
// websocket获取节点列表
client := gclient.NewWebSocket()
client.HandshakeTimeout = time.Second // 设置超时时间
client.Proxy = http.ProxyFromEnvironment // 设置代理
client.TLSClientConfig = &tls.Config{} // 设置 tls 配置
conn, _, err := client.Dial(wsUrl, nil)
if err != nil {
return err
}
_, data, err := conn.ReadMessage()
if err != nil {
return err
}
// 打印消息类型和消息内容
nodeList := gjson.New(string(data)).Get("body.outboundStatus").Array()
for _, v := range nodeList {
if !gjson.New(gconv.String(v)).Get("alive").Bool() {
continue
}
// 根据"delay"获得延迟最小的节点
if connectedNode == "" {
connectedNode = gconv.String(v)
} else {
if gjson.New(connectedNode).Get("delay").Int() > gjson.New(gconv.String(v)).Get("delay").Int() {
connectedNode = gconv.String(v)
}
}
}
// 比对缓存中的节点信息
cacheNodeInfo, _ := gcache.Get(context.Background(), manifest.ProxyNodeCacheKey)
if cacheNodeInfo != nil {
if gjson.New(cacheNodeInfo.String()).Get("nodeName").String() == gjson.New(connectedNode).Get("outbound_tag").String() {
lastChangeTime = gjson.New(cacheNodeInfo).Get("lastChangeTime").String()
} else {
lastChangeTime = gtime.Now().String()
}
} else {
lastChangeTime = gtime.Now().String()
}
// 获取节点信息
nodeInfo["nodeName"] = gjson.New(connectedNode).Get("outbound_tag").String()
nodeInfo["lastChangeTime"] = lastChangeTime
nodeInfo["updateTime"] = gtime.Now().String()
// 关闭连接
_ = conn.Close()
// 存入缓存
err = gcache.Set(context.Background(), manifest.ProxyNodeCacheKey, nodeInfo, 0)
if err != nil {
return err
}
return nil
}
// GetToken
//
// @dc: 获取v2raya面板token
// @author: laixin @date:2023/4/2 20:13:24
func (u *uNodeUtils) GetToken() (token string, err error) {
var (
url = "http://" + manifest.XrayBaseUrl + "/api/login"
)
// 登陆获取token
response, err := g.Client().Post(context.Background(), url, manifest.XrayLoginDataMap)
defer func(response *gclient.Response) {
err := response.Close()
if err != nil {
glog.Warning(context.Background(), err)
}
}(response)
if err != nil {
return "", err
}
resData := gjson.New(response.ReadAllString())
if resData.Get("code").String() != "SUCCESS" {
err = gerror.New("登陆失败")
return
}
token = resData.Get("data.token").String()
if token == "" {
err = gerror.New("token获取失败")
return
}
return
}

204
utility/network_utils/proxy_network.go Normal file
View File

@ -0,0 +1,204 @@
package network_utils
import (
"context"
"fmt"
"github.com/gogf/gf/v2/encoding/gjson"
"github.com/gogf/gf/v2/frame/g"
"github.com/gogf/gf/v2/net/gclient"
"github.com/gogf/gf/v2/os/gcache"
"github.com/gogf/gf/v2/os/glog"
"github.com/gogf/gf/v2/os/gtime"
"github.com/gogf/gf/v2/util/gconv"
"home-network-watcher/manifest"
"time"
)
type uProxyNetwork struct{}
var ProxyNetwork = &uProxyNetwork{}
// GetXuiUserList
//
// @dc: 获取xui用户列表
// @author: hamster @date:2023/9/19 09:29:33
func (u *uProxyNetwork) GetXuiUserList() (err error) {
var (
url = manifest.XuiBaseUrl + "/xui/inbound/list"
session map[string]string
)
// 尝试获取缓存中的session
sessionData, err := gcache.Get(context.Background(), manifest.ProxySessionCacheKey)
if err != nil {
return err
}
if sessionData.IsNil() {
// 重新获取session
session, err = u.GetXuiSession()
if err != nil {
return err
}
} else {
session = sessionData.MapStrStr()
}
if err != nil {
return err
}
post, err := g.Client().SetCookieMap(session).Post(context.Background(), url)
defer func(post *gclient.Response) {
err := post.Close()
if err != nil {
glog.Warning(context.Background(), err)
}
}(post)
if err != nil {
return err
}
if post.StatusCode != 200 {
glog.Warning(context.Background(), "获取xui用户列表失败")
return err
}
jsonData := gjson.New(post.ReadAllString())
userList := jsonData.Get("obj").Array()
// 删除敏感信息,计算总上传下载流量
userCacheList := make([]g.Map, 0)
upTotal := 0.00
downTotal := 0.00
for _, value := range userList {
userJson := gjson.New(value)
userCacheJson := g.Map{
"id": userJson.Get("id").Int(),
"enable": userJson.Get("enable").Bool(),
"protocol": userJson.Get("protocol").String(),
"remark": userJson.Get("remark").String(),
// 转换为 GB
"up": userJson.Get("up").Float64() / 1024 / 1024 / 1024,
"down": userJson.Get("down").Float64() / 1024 / 1024 / 1024,
}
userCacheList = append(userCacheList, userCacheJson)
upTotal += userJson.Get("up").Float64()
downTotal += userJson.Get("down").Float64()
}
// 按照下载流量排序
for i := 0; i < len(userCacheList); i++ {
for j := i + 1; j < len(userCacheList); j++ {
if userCacheList[i]["down"].(float64) < userCacheList[j]["down"].(float64) {
userCacheList[i], userCacheList[j] = userCacheList[j], userCacheList[i]
}
}
}
cacheXuiData := g.Map{
"user_list": userCacheList,
"user_count": len(userCacheList),
"up_total": upTotal / 1024 / 1024 / 1024,
"down_total": downTotal / 1024 / 1024 / 1024,
}
err = gcache.Set(context.Background(), manifest.XUIUserListCacheKey, cacheXuiData, 1*time.Minute)
return
}
// GetProxyNetwork
//
// @dc: 获取代理服务器的网速
// @author: laixin @date:2023/4/2 20:06:21
func (u *uProxyNetwork) GetProxyNetwork() (err error) {
var (
proxyNetwork = g.Map{
"time": "",
"rxSpeedKbps": 0,
"txSpeedKbps": 0,
"rxSpeedMbps": 0,
"txSpeedMbps": 0,
}
session map[string]string
url = manifest.XuiBaseUrl + "/server/status"
)
// 尝试获取缓存中的session
sessionData, err := gcache.Get(context.Background(), manifest.ProxySessionCacheKey)
if err != nil {
return err
}
if sessionData.IsNil() {
// 重新获取session
session, err = u.GetXuiSession()
if err != nil {
return err
}
} else {
session = sessionData.MapStrStr()
}
// 通过xui进行网速的获取
post, err := g.Client().SetCookieMap(session).Post(context.Background(), url)
defer func(post *gclient.Response) {
err := post.Close()
if err != nil {
glog.Warning(context.Background(), err)
}
}(post)
if err != nil {
return err
}
if post.StatusCode != 200 {
glog.Warning(context.Background(), "获取网速失败")
return err
}
jsonData := gjson.New(post.ReadAllString())
rxSpeed := jsonData.Get("obj.netIO.down") // 下载速度
txSpeed := jsonData.Get("obj.netIO.up") // 上传速度
// 速度单位转换
rxSpeedKbps := gconv.Float64(fmt.Sprintf("%.2f", gconv.Float64(rxSpeed)/1024))
txSpeedKbps := gconv.Float64(fmt.Sprintf("%.2f", gconv.Float64(txSpeed)/1024))
proxyNetwork["rxSpeedKbps"] = rxSpeedKbps
proxyNetwork["txSpeedKbps"] = txSpeedKbps
// 转换成MB
rxSpeedMbps := gconv.Float64(fmt.Sprintf("%.2f", gconv.Float64(rxSpeed)/1024/1024))
txSpeedMbps := gconv.Float64(fmt.Sprintf("%.2f", gconv.Float64(txSpeed)/1024/1024))
proxyNetwork["rxSpeedMbps"] = rxSpeedMbps
proxyNetwork["txSpeedMbps"] = txSpeedMbps
proxyNetwork["time"] = gtime.Now().String()
err = gcache.Set(context.Background(), manifest.ProxyNetworkCacheKey, proxyNetwork, 10*time.Second)
if err != nil {
return err
}
return err
}
// GetXuiSession
//
// @dc: 获取Xui登陆session
// @author: laixin @date:2023/4/2 20:06:21
func (u *uProxyNetwork) GetXuiSession() (sessionMap map[string]string, err error) {
var (
url = manifest.XuiBaseUrl + "/login"
)
post, err := g.Client().Post(context.Background(), url, manifest.XuiLoginDataMap)
defer func(post *gclient.Response) {
err := post.Close()
if err != nil {
glog.Warning(context.Background(), err)
}
}(post)
if err != nil {
return nil, err
}
if post.StatusCode != 200 {
return nil, fmt.Errorf("登录失败")
}
if post.Header.Get("Set-Cookie") == "" {
return nil, fmt.Errorf("获取Cookie失败")
}
// 将session存入缓存
err = gcache.Set(context.Background(), manifest.ProxySessionCacheKey, post.GetCookieMap(), 15*time.Minute)
if err != nil {
return nil, err
}
return post.GetCookieMap(), nil
}