ljydlv
/
videoplayer
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge branch 'refs/heads/release'

This commit is contained in:
junleea 2025-06-03 13:41:11 +08:00
parent 83552d12a2 d6bf91c9fd
commit 196887fa8b
8 changed files with 370 additions and 63 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
handler/cid.go
View File

@ -11,6 +11,7 @@ import (
"time"
"videoplayer/dao"
"videoplayer/proto"
"videoplayer/service"
"videoplayer/worker"
)
@ -62,7 +63,8 @@ func RunCID(c *gin.Context) {
id, _ := c.Get("id")
authID := int(id.(float64))
//获取权限
user := dao.FindUserByUserID(authID)
//user := dao.FindUserByUserID(authID)
user := service.GetUserByIDFromUserCenter(authID)
if user.Run == false {
c.JSON(200, gin.H{"error": "no run Permissions", "code": proto.NoRunPermissions, "message": "no run Permissions"})
return
@ -197,7 +199,8 @@ func CIDCallback(c *gin.Context) {
return
}
user := dao.FindUserByUserID(res.Auth_id)
//user := dao.FindUserByUserID(res.Auth_id)
user := service.GetUserByIDFromUserCenter(res.Auth_id)
if user.Run == false {
c.JSON(200, gin.H{"error": "no run Permissions", "code": proto.NoRunPermissions, "message": "the user has no run Permissions"})
return

61
handler/tool.go
View File

@ -4,6 +4,7 @@ import (
"fmt"
"github.com/gin-gonic/gin"
"io"
"log"
"net/http"
"os"
"strconv"
@ -58,40 +59,48 @@ func SetUpToolGroup(router *gin.Engine) {
func SetDeviceStatusV2(c *gin.Context) {
// TODO
var req SetDeviceStatusReq
var resp proto.GeneralResp
if err := c.ShouldBind(&req); err != nil {
c.JSON(200, gin.H{"code": 400, "message": "参数错误"})
return
resp.Code = proto.ParameterError
resp.Message = "参数解析失败：" + err.Error()
} else {
token := c.Request.Header.Get("token")
if token == "" {
c.JSON(200, gin.H{"code": 401, "message": "token为空"})
return
}
devices := worker.GetRedisSetMembers(token)
if len(devices) == 0 {
c.JSON(200, gin.H{"code": 402, "message": "设备为空"})
return
}
for _, v := range devices {
if v == req.ID {
// 继续处理请求
//是否是暂停之后第一次上线,如果是则发送邮件通知
device_status := worker.GetRedis("monitor_" + req.ID)
isExist := worker.IsContainKey("monitor_" + req.ID)
if device_status == "2" || !isExist {
//发送邮件通知
title := "设备上线"
content := "设备上线\n设备:" + req.ID + "\t状态:" + req.Status + "\t时间：" + time.Now().String()
go SendMail(title, content)
resp.Code = proto.TokenIsNull //token为空
} else {
devices := worker.GetRedisSetMembers(token)
if len(devices) == 0 {
resp.Code = proto.MonitorServerIDIsNull
resp.Message = "服务器设备监控为空!"
} else {
isExit := false
for _, v := range devices {
if v == req.ID {
// 继续处理请求
//是否是暂停之后第一次上线,如果是则发送邮件通知
deviceStatus := worker.GetRedis("monitor_" + req.ID)
isExist := worker.IsContainKey("monitor_" + req.ID)
if deviceStatus == "2" || !isExist {
//发送邮件通知
title := "设备上线"
content := "设备上线\n设备:" + req.ID + "\t状态:" + req.Status + "\t时间：" + time.Now().String()
go SendMail(title, content)
}
worker.SetRedisWithExpire("monitor_"+req.ID, "1", time.Second*300)
resp.Code = proto.SuccessCode
resp.Message = "success"
isExit = true
}
}
if isExit == false {
resp.Code = proto.MonitorServerIDNotFound
resp.Message = "设备不存在!"
log.Println("设备不存在,id:", req.ID, "\ttoken:", token, "\tdevices:", devices)
}
worker.SetRedisWithExpire("monitor_"+req.ID, "1", time.Second*300)
c.JSON(200, gin.H{"code": 0, "message": "success"})
return
}
}
c.JSON(200, gin.H{"code": 402, "message": "设备不存在"})
}
c.JSON(http.StatusOK, resp)
}
func GetFileList(c *gin.Context) {

28
main.go
View File

@ -31,9 +31,9 @@ func main() {
panic("failed to connect redis:" + err.Error())
}
r.Use(handler.CrosHandler())
r.Use(JWTAuthMiddleware()) // 使用 JWT 认证中间件
handler.SetUpVideoGroup(r) // Video
handler.SetUpUserGroup(r) // User
r.Use(JWTAuthMiddleware()) // 使用 JWT 认证中间件
handler.SetUpVideoGroup(r) // Video
//handler.SetUpUserGroup(r) // User
handler.SetUpDeviceGroup(r) // Device
handler.SetUpIMGroup(r) // IM
handler.SetUpCIDGroup(r) // CID,持续集成、部署
@ -124,12 +124,7 @@ func JWTAuthMiddleware() gin.HandlerFunc {
if proto.Config.TOKEN_USE_REDIS {
redisToken := worker.GetRedis(tokenString)
if redisToken == "" {
c.AbortWithStatus(200)
c.JSON(200, gin.H{
"message": "NOT_LOGIN",
"error": "server token is empty",
"code": proto.TokenIsNull,
})
c.AbortWithStatusJSON(http.StatusOK, gin.H{"message": "NOT_LOGIN", "error": "server token is empty", "code": proto.TokenIsNull})
return
}
}
@ -141,12 +136,7 @@ func JWTAuthMiddleware() gin.HandlerFunc {
sId = c.Query("super_id")
}
if sId == "" {
c.AbortWithStatus(200)
c.JSON(200, gin.H{
"message": "NOT_LOGIN",
"error": "super_id is empty",
"code": proto.TokenIsNull,
})
c.AbortWithStatusJSON(http.StatusOK, gin.H{"message": "unauthorized", "error": "super_id is empty", "code": proto.TokenIsNull})
return
}
id, _ := strconv.Atoi(sId)
@ -164,8 +154,7 @@ func JWTAuthMiddleware() gin.HandlerFunc {
// 验证令牌
if err != nil || !token.Valid {
c.AbortWithStatus(200)
c.JSON(200, gin.H{
c.AbortWithStatusJSON(http.StatusOK, gin.H{
"message": "NOT_LOGIN",
"error": "Invalid token",
"code": proto.TokenExpired,
@ -178,8 +167,7 @@ func JWTAuthMiddleware() gin.HandlerFunc {
c.Set("username", token.Claims.(jwt.MapClaims)["username"])
if UserFuncIntercept(int(token.Claims.(jwt.MapClaims)["id"].(float64)), c.Request.URL.Path) {
c.AbortWithStatus(200)
c.JSON(http.StatusOK, gin.H{
c.AbortWithStatusJSON(http.StatusOK, gin.H{
"message": "no function permission",
"error": "no permission",
"code": proto.NoPermission,
@ -351,7 +339,7 @@ func RunGeneralCron() {
// 用户功能拦截,返回true表示拦截，false表示不拦截
func UserFuncIntercept(id int, url string) bool {
//先查看是否有权限
user := dao.FindUserByUserID(id)
user := service.GetUserByIDFromUserCenter(id)
//如果用户有权限，则不拦截
for k, v := range proto.Per_menu_map {
if strings.Contains(url, k) {

7
proto/req.go Normal file
View File

@ -0,0 +1,7 @@
package proto
type GeneralResp struct {
Code int `json:"code"`
Message string `json:"message"`
Data any `json:"data"`
}

5
proto/status.go
View File

@ -73,4 +73,9 @@ const (
ShellUpdateFailed = 101 // 更新shell失败
ShellDeleteFailed = 102 // 删除shell失败
ShellSearchFailed = 103 // 获取shell失败
//monitor部分错误码
MonitorServerIDIsNull = 110 // 监控服务器ID为空
MonitorServerIDNotFound = 111 // 监控服务器ID不存在
)

79
service/userService.go
View File

@ -5,6 +5,7 @@ import (
"errors"
"fmt"
"github.com/golang-jwt/jwt"
"log"
"regexp"
"strconv"
"time"
@ -124,8 +125,8 @@ func UpdateUser(user_id int, req proto.UpdateUserInfoReq) (int, error) {
func UpdateUserCache(id int) {
key := "user_info_" + strconv.Itoa(id)
if worker.IsContainKey(key) {
user := GetUserByID(id)
userJson, err := json.Marshal(user)
users := GetUserByID(id)
userJson, err := json.Marshal(users[0]) //统一使用User不使用数组
if err != nil {
fmt.Println("get user info , json marshal error:", err)
}
@ -400,3 +401,77 @@ func CreateTokenAndSave(user dao.User) (string, error) {
// 返回令牌
return tokenString, err
}
// 获取用户信息，有redis缓存
func GetUserByIDFromUserCenter(id int) dao.User {
if id <= 0 {
return dao.User{}
}
var user dao.User
//先从redis获取
key := "user_info_" + strconv.Itoa(id)
userStr := worker.GetRedis(key)
//log.Println("user_str:", userStr)
if userStr != "" {
err := json.Unmarshal([]byte(userStr), &user)
if err != nil {
fmt.Println("get user info , json unmarshal error:", err, "\tuser_str:", userStr)
return dao.User{}
}
} else {
user = GetUserInfoByIDFromUserCenterHttp(id)
if user.ID != 0 {
userJson, err := json.Marshal(user)
if err != nil {
fmt.Println("get user info , json marshal error:", err)
return dao.User{}
}
userStr = string(userJson)
success := worker.SetRedisWithExpire(key, userStr, time.Second*10)
if !success {
fmt.Println("set redis error,user json:", userStr)
}
} else {
log.Println("GetUserByIDFromUserCenter user not found, id:", id)
log.Println("response user:", user)
}
}
return user
}
type UserInfoResponse struct {
Code int `json:"code"`
Message string `json:"message"`
Data dao.User `json:"data"`
}
func GetUserInfoByIDFromUserCenterHttp(id int) dao.User {
var resp UserInfoResponse
url := "https://uc.ljsea.top/user/info?super_id=1"
tokens := worker.GetRedisSetMembers("super_permission_tokens")
if len(tokens) == 0 {
return resp.Data
}
token := tokens[0]
//请求参数
req := map[string]int{
"id": id,
}
headers := map[string]string{
"token": token,
}
reqByte, _ := json.Marshal(req)
err, respBytes := worker.DoPostRequestJSON(url, reqByte, headers)
if err != nil {
log.Println("GetUserInfoByIDFromUserCenterHttp error:", err)
return resp.Data
}
if err2 := json.Unmarshal(respBytes, &resp); err2 != nil {
log.Println("GetUserInfoByIDFromUserCenterHttp json unmarshal error:", err2)
}
if resp.Data.ID == 0 {
log.Println("GetUserInfoByIDFromUserCenterHttp user not found, resp:", string(respBytes))
return resp.Data
}
return resp.Data
}

26
worker/redis.go
View File

@ -50,7 +50,7 @@ func IsContainKey(key string) bool {
ctx := context.Background()
val, err := RedisClient.Exists(ctx, key).Result() // 检查键是否存在, 如果存在则返回 1, 否则返回 0
if err != nil {
fmt.Println("Error getting key: %v", err)
//fmt.Println("Error getting key: %v", err)
return false
}
if val == 0 {
@ -170,7 +170,7 @@ func GetRedis(key string) string {
ctx := context.Background()
val, err := RedisClient.Get(ctx, key).Result() // 从 Redis 读取键值, 如果键不存在则返回空字符串, 如果出现错误则返回错误
if err != nil {
fmt.Println(key, " Error getting key: %v", err)
//fmt.Println(key, " Error getting key: %v", err)
return ""
}
return val
@ -220,7 +220,7 @@ func GetRedisListLen(key string) int64 {
ctx := context.Background()
val, err := RedisClient.LLen(ctx, key).Result()
if err != nil {
fmt.Println("Error getting key: %v", err)
//fmt.Println("Error getting key: %v", err)
return 0
}
return val
@ -281,7 +281,7 @@ func hGetRedis(key string, field string) string {
ctx := context.Background()
val, err := RedisClient.HGet(ctx, key, field).Result()
if err != nil {
fmt.Println("Error getting key: %v", err)
//fmt.Println("Error getting key: %v", err)
}
return val
}
@ -362,7 +362,7 @@ func GetRedisSetIntersect(key1 string, key2 string) []string {
ctx := context.Background()
val, err := RedisClient.SInter(ctx, key1, key2).Result()
if err != nil {
fmt.Println("Error getting key: %v", err)
//fmt.Println("Error getting key: %v", err)
return nil
}
return val
@ -373,7 +373,7 @@ func IsContainSet(key string, value string) bool {
ctx := context.Background()
val, err := RedisClient.SIsMember(ctx, key, value).Result()
if err != nil {
fmt.Println("Error getting key: %v", err)
//fmt.Println("Error getting key: %v", err)
return false
}
return val
@ -384,7 +384,7 @@ func GetRedisSetMembers(key string) []string {
ctx := context.Background()
val, err := RedisClient.SMembers(ctx, key).Result()
if err != nil {
fmt.Println("Error getting key: %v", err)
//fmt.Println("Error getting key: %v", err)
return nil
}
return val
@ -395,7 +395,7 @@ func SetRedisBitmap(key string, offset int64, value int) bool {
ctx := context.Background()
err := RedisClient.SetBit(ctx, key, offset, value).Err()
if err != nil {
fmt.Println("Error setting key: %v", err)
//fmt.Println("Error setting key: %v", err)
return false
}
return true
@ -406,7 +406,7 @@ func GetRedisBitmap(key string, offset int64) int {
ctx := context.Background()
val, err := RedisClient.GetBit(ctx, key, offset).Result()
if err != nil {
fmt.Println("Error getting key: %v", err)
//fmt.Println("Error getting key: %v", err)
return 0
}
return int(val)
@ -476,7 +476,7 @@ func GetRedisSetUnion(key1 string, key2 string) []string {
ctx := context.Background()
val, err := RedisClient.SUnion(ctx, key1, key2).Result()
if err != nil {
fmt.Println("Error getting key: %v", err)
//fmt.Println("Error getting key: %v", err)
return nil
}
return val
@ -494,7 +494,7 @@ func GetAllRedisInfo() ([]RedisInfo, error) {
ctx := context.Background()
keys, err := RedisClient.Keys(ctx, "*").Result()
if err != nil {
fmt.Println("Error getting key: %v", err)
//fmt.Println("Error getting key: %v", err)
return nil, err
}
var redisInfos []RedisInfo
@ -502,12 +502,12 @@ func GetAllRedisInfo() ([]RedisInfo, error) {
//先查看key类型，再根据类型获取value
key_type, val, err := getKeyTypeAndData(key)
if err != nil {
fmt.Println("Error getting key: %v", err)
//fmt.Println("Error getting key: %v", err)
return nil, err
}
expire, err := RedisClient.TTL(ctx, key).Result()
if err != nil {
fmt.Println("Error getting key: %v", err)
//fmt.Println("Error getting key: %v", err)
return nil, err
}
redisInfo := RedisInfo{

220
worker/req.go
View File

@ -6,7 +6,11 @@ import (
"fmt"
"io"
"io/ioutil"
"log"
"mime/multipart"
"net/http"
"net/url"
"strconv"
"strings"
"videoplayer/dao"
"videoplayer/proto"
@ -279,3 +283,219 @@ func SyncDataFromMasterShellReq3(url string, data proto.SyncUserShellResp) ([]pr
res = response.Data
return res, nil
}
func DoPostRequestJSON(url string, jsonData []byte, headers map[string]string) (error, []byte) {
httpClient := &http.Client{}
defer func() {
if r := recover(); r != nil {
fmt.Println("SyncDataFromMasterReq2 error:", r)
}
}()
//从接口获取数据
req, err := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
if err != nil {
return err, nil
}
req.Header.Set("Content-Type", "application/json")
req.Header.Set("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/136.0.0.0 Safari/537.36 Edg/136.0.0.0")
//设置header
for k, v := range headers {
req.Header.Set(k, v)
}
//传输数据
if httpClient == nil {
httpClient = &http.Client{}
}
//获取数据
resp, err := httpClient.Do(req)
if err != nil {
return err, nil
}
defer resp.Body.Close()
//解析数据
responseBod, err := io.ReadAll(resp.Body)
if err != nil {
return err, nil
}
return err, responseBod
}
func DoPostRequestForm(url string, jsonData []byte, headers map[string]string) (error, []byte) {
httpClient := &http.Client{}
defer func() {
if r := recover(); r != nil {
fmt.Println("SyncDataFromMasterReq2 error:", r)
}
}()
// 创建一个新的 buffer 用于存储 multipart/form-data 请求体
body := &bytes.Buffer{}
writer := multipart.NewWriter(body)
// 修改 data 类型为 map[string]interface{} 以支持不同类型的值
var data map[string]interface{}
err2 := json.Unmarshal(jsonData, &data)
if err2 != nil {
log.Println("do post json unmarshal error:", err2)
return err2, nil
}
var err error
for k, v := range data {
switch val := v.(type) {
case bool:
// 处理布尔类型的值
err = writer.WriteField(k, strconv.FormatBool(val))
case string:
// 处理字符串类型的值
err = writer.WriteField(k, val)
default:
// 其他类型可以根据需要扩展处理逻辑
log.Printf("Unsupported type for field %s: %T\n", k, v)
continue
}
if err != nil {
log.Println("write field error:", err)
return err, nil
}
}
// 关闭 writer 以完成请求体的构建
err = writer.Close()
if err != nil {
return err, nil
}
// 创建 POST 请求
req, err := http.NewRequest("POST", url, body)
req.Header.Set("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/136.0.0.0 Safari/537.36 Edg/136.0.0.0")
if err != nil {
return err, nil
}
// 设置 Content-Type 为 multipart/form-data，并带上 boundary
req.Header.Set("Content-Type", writer.FormDataContentType())
// 设置其他自定义请求头
for k, v := range headers {
req.Header.Set(k, v)
}
// 发送请求
resp, err := httpClient.Do(req)
if err != nil {
return err, nil
}
defer resp.Body.Close()
// 读取响应体
responseBod, err := io.ReadAll(resp.Body)
if err != nil {
return err, nil
}
return nil, responseBod
}
func DoPostRequestFormUrlEncoded(url_ string, jsonData []byte, headers map[string]string) (error, []byte) {
httpClient := &http.Client{}
defer func() {
if r := recover(); r != nil {
log.Println("SyncDataFromMasterReq2 error:", r)
}
}()
// 解析 JSON 数据
var data map[string]interface{}
err := json.Unmarshal(jsonData, &data)
if err != nil {
log.Println("do post json unmarshal error:", err)
return err, nil
}
// 创建 url.Values 来存储请求参数
reqData := url.Values{}
for k, v := range data {
switch val := v.(type) {
case bool:
// 处理布尔类型的值
reqData.Set(k, strconv.FormatBool(val))
case string:
// 处理字符串类型的值
reqData.Set(k, val)
default:
// 其他类型可以根据需要扩展处理逻辑
log.Printf("Unsupported type for field %s: %T\n", k, v)
continue
}
}
// 将 url.Values 编码为 URL 编码的格式
encodedData := reqData.Encode()
// 创建 POST 请求
req, err := http.NewRequest("POST", url_, bytes.NewBufferString(encodedData))
if err != nil {
return err, nil
}
// 设置请求头
req.Header.Set("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/136.0.0.0 Safari/537.36 Edg/136.0.0.0")
req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
// 设置其他自定义请求头
for k, v := range headers {
req.Header.Set(k, v)
}
// 发送请求
resp, err := httpClient.Do(req)
if err != nil {
return err, nil
}
defer resp.Body.Close()
// 读取响应体
responseBod, err := io.ReadAll(resp.Body)
if err != nil {
return err, nil
}
return nil, responseBod
}
func DoGetRequest(url string, headers map[string]string) (error, []byte) {
httpClient := &http.Client{}
defer func() {
if r := recover(); r != nil {
fmt.Println("SyncDataFromMasterReq2 error:", r)
}
}()
//从接口获取数据
req, err := http.NewRequest("GET", url, nil)
req.Header.Set("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/136.0.0.0 Safari/537.36 Edg/136.0.0.0")
if err != nil {
return err, nil
}
//设置header
for k, v := range headers {
req.Header.Set(k, v)
}
//传输数据
if httpClient == nil {
httpClient = &http.Client{}
}
//获取数据
resp, err := httpClient.Do(req)
if err != nil {
return err, nil
}
defer resp.Body.Close()
//解析数据
responseBod, err := io.ReadAll(resp.Body)
if err != nil {
return err, nil
}
return err, responseBod
}