task rules set complete

liuxiaolong

2019-06-20 cb707715e4648719a5ab083f0623620079b20f2a

task rules set complete

 controllers/cameraTask.go

@@ -2,10 +2,10 @@

import (
    "basic.com/dbapi.git"
    "webserver/extend/code"
    "webserver/extend/util"
    "fmt"
    "github.com/gin-gonic/gin"
    "webserver/extend/code"
    "webserver/extend/util"
    "webserver/models"
)

@@ -173,37 +173,88 @@
    }
}

type TransAndAlarmLevelVo struct {
type DataTransVo struct {
    CameraIds []string `json:"camera_ids"`
    TaskId string `json:"task_id"`
    IsDataTrans int `json:"is_data_trans"`
    GroupLevels []GroupAlarmLevelVo `json:"group_levels"`
}
type GroupAlarmLevelVo struct {
    GroupId string `json:"group_id"`
    AlarmLevel int `json:"alarm_level"`
}

// @Summary 保存任务是否下传数据以及组报警等级
// @Description 保存任务是否下传数据以及组报警等级
// @Summary 保存任务是否下传数据
// @Description 保存任务是否下传数据
// @Accept json
// @Produce json
// @Tags CameraTask
// @Param TransAndAlarmLevel body controllers.TransAndAlarmLevelVo true "请求参数结构"
// @Param TransAndAlarmLevel body controllers.DataTransVo true "请求参数结构"
// @Success 200 {string} json "{"code":200, success:true, msg:"", data:""}"
// @Failure 500 {string} json "{"code":500, success:false, msg:"", data:""}"
// @Router /data/api-v/cameraTask/saveTransAndAlarmLevel [post]
func (controller CameraTaskController) SaveTransAndAlarmLevel(c *gin.Context) {
    var vo TransAndAlarmLevelVo
    if err := c.BindJSON(&vo);err!=nil {
// @Router /data/api-v/cameraTask/saveIsDataTrans [post]
func (controller CameraTaskController) SaveIsDataTrans(c *gin.Context) {
    var transVo DataTransVo
    if err := c.BindJSON(&transVo);err!=nil {
        util.ResponseFormat(c,code.RequestParamError,"参数有误")
        return
    }
    fmt.Println("SaveTransAndAlarmLevel.vo:",vo)
    var api dbapi.CameraTaskApi
    paramBody := util.Struct2Map(vo)
    paramBody := util.Struct2Map(transVo)

    flag ,data := api.SaveTransAndAlarmLevel(paramBody)
    flag ,data := api.SaveIsDataTrans(paramBody)
    if flag {
        util.ResponseFormat(c,code.Success,data)
    } else {
        util.ResponseFormat(c,code.ComError,data)
    }
}

// @Summary 保存规则组报警等级
// @Description 保存规则组报警等级
// @Produce json
// @Tags CameraTask
// @Param GroupLevel body controllers.GroupAlarmLevelVo true "alarmLevel"
// @Success 200 {string} json "{"code":200, success:true, msg:"", data:""}"
// @Failure 500 {string} json "{"code":500, success:false, msg:"", data:""}"
// @Router /data/api-v/cameraTask/saveAlarmLevelByGroup [post]
func (controller CameraTaskController) SaveAlarmLevelByGroup(c *gin.Context) {
    var groupLevelVo GroupAlarmLevelVo
    if err := c.BindJSON(&groupLevelVo);err !=nil {
        util.ResponseFormat(c,code.RequestParamError,"参数有误")
        return
    }

    var api dbapi.CameraTaskApi
    flag,data := api.SaveAlarmLevelByGroup(groupLevelVo.GroupId,groupLevelVo.AlarmLevel)
    if flag {
        util.ResponseFormat(c,code.Success,data)
    } else {
        util.ResponseFormat(c,code.ComError,data)
    }
}

type CameraTaskStatusVo struct {
    CameraId string `json:"cameraId"`
    TaskId string `json:"taskId"`
    Status int `json:"status"`
}

// @Summary 更新任务状态
// @Description 更新任务状态
// @Produce json
// @Tags CameraTask
// @Param CameraTaskStatus body controllers.CameraTaskStatusVo true "参数结构体"
// @Success 200 {string} json "{"code":200, success:true, msg:"", data:""}"
// @Failure 500 {string} json "{"code":500, success:false, msg:"", data:""}"
// @Router /data/api-v/cameraTask/updateCameraTaskStatus [post]
func (controller CameraTaskController) UpdateCameraTaskStatus(c *gin.Context) {
    var paramVo CameraTaskStatusVo
    if err := c.BindJSON(&paramVo);err !=nil {
        util.ResponseFormat(c,code.RequestParamError,"参数有误")
        return
    }
    var api dbapi.CameraTaskApi
    flag, data := api.UpdateCameraTaskStatus(paramVo.CameraId, paramVo.TaskId, paramVo.Status)
    if flag {
        util.ResponseFormat(c,code.Success,data)
    } else {

 controllers/cameraTaskArgs.go

@@ -48,15 +48,16 @@
// @Param cameraIds body controllers.MultiCamera true "摄像机ids"
// @Success 200 {string} json "{"code":200, success:true, msg:"", data:""}"
// @Failure 500 {string} json "{"code":500, success:false, msg:"",data:""}"
// @Router /data/api-v/cameraTaskArgs/getLinkRulesByCameraIds [get]
// @Router /data/api-v/cameraTaskArgs/getLinkRulesByCameraIds [post]
func (controller CameraTaskArgsController) GetLinkRulesByCameraIds(c *gin.Context) {
    var cameraIds MultiCamera
    if err := c.BindJSON(&cameraIds);err !=nil {
    var cameraIdsVo MultiCamera
    if err := c.BindJSON(&cameraIdsVo);err !=nil {
        util.ResponseFormat(c,code.RequestParamError,"参数有误")
        return
    }
    var api dbapi.CameraTaskArgsApi
    flag,data := api.GetLinkRulesByCameraIds()
    paramBody := util.Struct2Map(cameraIdsVo)
    flag,data := api.GetLinkRulesByCameraIds(paramBody)
    if flag {
        util.ResponseFormat(c,code.Success,data)
    } else {

 controllers/cameraTimerule.go

@@ -51,7 +51,7 @@
    paramBody["id"] = vo.Id
    paramBody["name"] = vo.Name
    paramBody["time_rule"] = vo.TimeRule
    fmt.Println("paramBody: ", paramBody)

    var api dbapi.CameraApi
    flag, data := api.SaveCameraTimerule(paramBody)
    if flag {

 controllers/sdk.go

@@ -20,8 +20,8 @@
    CreateTime string `json:"create_time"`
    CreateBy string `json:"create_by"`
    UpdateTime string `json:"update_time"`
    Enabled int `json:"enabled"`//是否启用
    DelFlag int `json:"del_flag"`//逻辑删除
    Enable bool `json:"enable"`//是否启用
    DelFlag bool `json:"del_flag"`//逻辑删除
}

//算法参数定义

 controllers/task.go

@@ -2,11 +2,12 @@

import (
    "basic.com/dbapi.git"
    "encoding/json"
    "time"

    "github.com/gin-gonic/gin"
    "webserver/extend/code"
    "webserver/extend/util"
    "github.com/gin-gonic/gin"
)

type TaskController struct{}
@@ -22,6 +23,11 @@
    DelFlag  bool `json:"del_flag"`
}

type TaskSdkVo struct {
    Task TaskVo `json:"task"`
    Sdks []SdkVo `json:"sdks"`
}

// @Summary 查找所有任务，包含任务信息和对应的算法信息
// @Description 查找所有任务
// @Produce json
@@ -34,7 +40,17 @@
    var taskApi dbapi.TaskApi

    taskInfos := taskApi.FindAll()
    util.ResponseFormat(c, code.Success, taskInfos)
    var tasks []TaskSdkVo
    dataBytes, err := json.Marshal(taskInfos)
    if err !=nil {
        util.ResponseFormat(c,code.ComError,[]TaskSdkVo{})
    } else {
        if err := json.Unmarshal(dataBytes, &tasks);err !=nil {
            util.ResponseFormat(c,code.ComError,[]TaskSdkVo{})
        } else {
            util.ResponseFormat(c,code.Success,tasks)
        }
    }
}

// @Summary 添加任务

 controllers/user.go

@@ -1,9 +1,47 @@
package controllers

import (
    "basic.com/dbapi.git"
    "github.com/gin-gonic/gin"
    "webserver/extend/code"
    "webserver/extend/util"
    "webserver/middlewares/auth"
)

func Login(c *gin.Context) {
type UserController struct {

}

type UserVo struct {
    UserName string `json:"username"`
    Password string `json:"password"`
}

// @Summary 用户登录
// @Description 用户登录
// @Accept json
// @Produce json
// @Tags 用户
// @Param user body UserVo true "用户信息"
// @Success 200 {string} json "{"code":200, success:true, msg:"", data:""}"
// @Failure 500 {string} json "{"code":500, success:false, msg:"", data:""}"
// @Router /data/api-v/user/login [post]
func (controller UserController) Login(c *gin.Context) {
    var userVo UserVo
    if err := c.BindJSON(&userVo);err !=nil {
        util.ResponseFormat(c,code.RequestParamError,"参数有误")
        return
    }
    var api dbapi.UserApi
    flag, userInfo := api.Login(userVo.UserName, userVo.Password)
    if flag {
        authDriver := auth.GenerateAuthDriver()
        tokenStr := (*authDriver).Login(c.Request, c.Writer, util.Struct2Map(userInfo))
        util.ResponseFormat(c,code.Success,map[string]interface{}{
            "userInfo":userInfo,
            "token":tokenStr,
        })
    } else {
        util.ResponseFormat(c,code.SigninInfoError,"用户名或密码错误")
    }
}

 main.go

@@ -20,6 +20,7 @@
    config.Init(*envirment)
    models.Init()
    r := router.NewRouter()

    r.Run("0.0.0.0:8000")

    defer models.CloseDB()

 middlewares/auth/auth.go

@@ -1 +1,46 @@
package auth

import (
    "github.com/gin-gonic/gin"
    "net/http"
    "strings"
    "webserver/extend/code"
    "webserver/extend/util"
)

const (
    TokenKey = "abc123456789"
)

type Auth interface {
    Check(c *gin.Context)bool
    User(c *gin.Context)interface{}
    Login(http *http.Request,w http.ResponseWriter,user map[string]interface{})interface{}
    Logout(http *http.Request,w http.ResponseWriter) bool
}

func GenerateAuthDriver() *Auth {
    var authDriver Auth
    authDriver = NewJwtAuthDriver()
    return &authDriver
}

func AuthHandler() gin.HandlerFunc {
    return func(c *gin.Context) {
        urlPath := c.Request.URL.Path
        if strings.Contains(urlPath,"/data/api-v") && !strings.Contains(urlPath,"login"){
            jwtDriver :=NewJwtAuthDriver()
            if !jwtDriver.Check(c) {
                util.ResponseFormat(c,code.TokenNotFound,"尚未登录，请登录")
                c.Abort()
            }
            c.Next()
        } else {
            c.Next()
        }
    }
}

func GetCurUser(c *gin.Context)map[string]interface{}{
    return (*GenerateAuthDriver()).User(c).(map[string]interface{})
}

 middlewares/auth/jwt.go

@@ -1 +1,108 @@
package auth

import (
    "encoding/json"
    "errors"
    jwtLib "github.com/dgrijalva/jwt-go"
    "github.com/dgrijalva/jwt-go/request"
    "github.com/gin-gonic/gin"
    "net/http"
    "strings"
    "time"
)

type jwtAuthManager struct {
    secret string
    expire time.Duration
    alg string
}

func NewJwtAuthDriver() *jwtAuthManager{
    return &jwtAuthManager{
        secret:TokenKey,
        expire:time.Hour*8,
        alg:"HS256",
    }
}

func (jwtAuth *jwtAuthManager) Check(c *gin.Context) bool {
    token := c.Request.Header.Get("Authorization")
    b := "Bearer "
    if !strings.Contains(token, b) {
        return false
    }
    t := strings.Split(token, b)
    if len(t) < 2 {
        return false
    }
    var keyFunc = func(token *jwtLib.Token) (interface{},error) {
        b := []byte(jwtAuth.secret)
        return b,nil
    }
    authJwtToken, err:= request.ParseFromRequest(c.Request,request.OAuth2Extractor,keyFunc)
    if err !=nil {
        return false
    }

    c.Set("User",map[string]interface{}{
        "token":authJwtToken,
    })

    return authJwtToken.Valid
}

func (jwtAuth *jwtAuthManager) User(c *gin.Context) interface{}{
    var jwtToken *jwtLib.Token
    if jwtUser, exist := c.Get("User");!exist{
        tokenStr :=strings.Replace(c.Request.Header.Get("Authorization"),"Bearer ","",-1)
        if tokenStr == ""{
            return map[interface{}]interface{}{}
        }
        var err error
        jwtToken,err = jwtLib.Parse(tokenStr, func(token *jwtLib.Token) (interface{}, error) {
            b :=[]byte(jwtAuth.secret)
            return b,nil
        })
        if err !=nil {
            panic(err)
        }
    } else {
        jwtToken = jwtUser.(map[string]interface{})["token"].(*jwtLib.Token)
    }
    if claims,ok :=jwtToken.Claims.(jwtLib.MapClaims);ok && jwtToken.Valid{
        var user map[string]interface{}
        if err := json.Unmarshal([]byte(claims["user"].(string)), &user); err != nil {
            panic(err)
        }
        c.Set("User", map[string]interface{}{
            "token": jwtToken,
            "user":  user,
        })
        return user
    } else {
        panic(errors.New("decode jwt user claims fail"))
    }
}

func (jwtAuth *jwtAuthManager) Login(http *http.Request, w http.ResponseWriter, user map[string]interface{}) interface{} {

    token := jwtLib.New(jwtLib.GetSigningMethod(jwtAuth.alg))

    userStr, err := json.Marshal(user)
    token.Claims = jwtLib.MapClaims{
        "user": string(userStr),
        "exp":  time.Now().Add(jwtAuth.expire).Unix(),
    }

    tokenString, err := token.SignedString([]byte(jwtAuth.secret))
    if err != nil {
        return nil
    }

    return tokenString
}

func (jwtAuth *jwtAuthManager) Logout(http *http.Request, w http.ResponseWriter) bool {

    return true
}

 router/router.go

@@ -1,17 +1,19 @@
package router

import (
    "webserver/controllers"
    "github.com/gin-gonic/gin"
    "github.com/swaggo/gin-swagger"
    "github.com/swaggo/gin-swagger/swaggerFiles"
    "github.com/szuecs/gin-glog"
    "time"
    "webserver/controllers"
)

func NewRouter() *gin.Engine {
    r := gin.Default()
    r.Use(ginglog.Logger(3 * time.Second))

    //r.Use(auth.AuthHandler())//auth过滤器

    r.GET("/swagger/*any", ginSwagger.WrapHandler(swaggerFiles.Handler))

@@ -29,11 +31,13 @@
    cameraTaskController :=new(controllers.CameraTaskController)
    cameraTaskArgsController :=new(controllers.CameraTaskArgsController)
    dicController :=new(controllers.DictionaryController)
    userController :=new(controllers.UserController)

    urlPrefix := "/data/api-v" // wp 添加 路径 前缀

    r.POST("/signup", controllers.Signup)
    r.POST("/signin", controllers.Login)
    userApi :=r.Group(urlPrefix+"/user")
    {
        userApi.POST("/login",userController.Login)
    }

    //区域管理
    area := r.Group(urlPrefix + "/area")
@@ -56,8 +60,7 @@
        camera.POST("/alltask", cameraTaskController.FindTasksByCameraIds)
        camera.GET("/task/:cameraId", cameraTaskController.CameraTaskAll)

        camera.GET("/delTask/:cid", cameraController.CameraDelTask)
        camera.DELETE("/task/del/:cid/:tid", cameraController.CameraDelTask)
        camera.GET("/delTask/:cameraId/:taskId", cameraController.CameraDelTask)
        camera.POST("/saveTask", cameraController.CameraTaskSave)
        camera.GET("/getRulesByCameraAndTask",cameraTaskArgsController.FindByCameraAndTask)
    }
@@ -65,13 +68,15 @@
    cameraTaskArgsApi :=r.Group(urlPrefix + "/cameraTaskArgs")
    {
        cameraTaskArgsApi.GET("/deleteByGroup",cameraTaskArgsController.DeleteByGroup)
        cameraTaskArgsApi.GET("/getLinkRulesByCameraIds",cameraTaskArgsController.GetLinkRulesByCameraIds)
        cameraTaskArgsApi.POST("saveLinkRulesByGroup",cameraTaskArgsController.SaveLinkRulesByGroup)
        cameraTaskArgsApi.POST("/getLinkRulesByCameraIds",cameraTaskArgsController.GetLinkRulesByCameraIds)
        cameraTaskArgsApi.POST("/saveLinkRulesByGroup",cameraTaskArgsController.SaveLinkRulesByGroup)
    }

    cameraTaskApi := r.Group(urlPrefix + "/cameraTask")
    {
        cameraTaskApi.POST("/saveTransAndAlarmLevel",cameraTaskController.SaveTransAndAlarmLevel)
        cameraTaskApi.POST("/saveIsDataTrans",cameraTaskController.SaveIsDataTrans)
        cameraTaskApi.POST("/saveAlarmLevelByGroup",cameraTaskController.SaveAlarmLevelByGroup)
        cameraTaskApi.POST("/updateCameraTaskStatus",cameraTaskController.UpdateCameraTaskStatus)
    }

    polygon := r.Group(urlPrefix+"/polygon")