rm task,cameraTask,cameraTaskArgs add cameraRule

liuxiaolong

2020-06-23 da4c92f310f5e856fc7a37056616990ceac2e098

rm task,cameraTask,cameraTaskArgs add cameraRule

 cameraApi.go

@@ -172,27 +172,27 @@
    return res.Success,res.Data
}

//获取所有摄像机的信息以及其所有任务
func (api CameraApi) FindAllCameraAndTask() (cameraTasks []protomsg.CameraAndTaskInfo){
    url := api.getBasicUrl() + DATA_URL_PREFIX + "/camera/queryCameraAndTaskInfo"
    client := NewClient()

    body, err := client.DoGetRequest(url, nil, nil)
    if err != nil {
        return nil
    }

    var res Result
    if err = json.Unmarshal(body, &res); err != nil {
        logPrint(err)
        return nil
    }

    bytes, _ := json.Marshal(res.Data)
    err = json.Unmarshal(bytes, &cameraTasks)

    return cameraTasks
}
////获取所有摄像机的信息以及其所有任务
//func (api CameraApi) FindAllCameraAndTask() (cameraTasks []protomsg.CameraAndTaskInfo){
//    url := api.getBasicUrl() + DATA_URL_PREFIX + "/camera/queryCameraAndTaskInfo"
//    client := NewClient()
//
//    body, err := client.DoGetRequest(url, nil, nil)
//    if err != nil {
//        return nil
//    }
//
//    var res Result
//    if err = json.Unmarshal(body, &res); err != nil {
//        logPrint(err)
//        return nil
//    }
//
//    bytes, _ := json.Marshal(res.Data)
//    err = json.Unmarshal(bytes, &cameraTasks)
//
//    return cameraTasks
//}

func (api CameraApi) SaveCameraPolygon(paramBody map[string]interface{}) (bool,interface{}) {
    url := api.getBasicUrl() + DATA_URL_PREFIX + "/polygon/save"

 cameraRuleApi.go

New file
@@ -0,0 +1,146 @@
package dbapi

import (
    "basic.com/pubsub/protomsg.git"
    "encoding/json"
    "strconv"
)

type CameraRuleApi struct{
    Ip string
    Port int
}

func (api CameraRuleApi) getBasicUrl() string {
    if api.Ip == "" {
        return BASIC_URL
    }
    if api.Ip == "" {
        api.Ip = DEFAULT_IP
    }
    if api.Port == 0 {
        api.Port = DEFAULT_PORT
    }
    return "http://"+api.Ip+":"+strconv.Itoa(api.Port)
}

func (api CameraRuleApi) Save(reqBody map[string]interface{}) bool {
    url := api.getBasicUrl() + DATA_URL_PREFIX + "/camera/rule/save"
    client := NewClient()
    body, err := client.DoPostRequest(url,CONTENT_TYPE_JSON, reqBody,nil,nil)
    if err != nil {
        return false
    }

    var res Result
    if err = json.Unmarshal(body, &res); err != nil {
        return false
    }
    return res.Success
}

func (api CameraRuleApi) PasteRules(reqBody map[string]interface{}) bool {
    url := api.getBasicUrl() + DATA_URL_PREFIX + "/camera/pasteRules"
    client := NewClient()
    body, err := client.DoPostRequest(url,CONTENT_TYPE_JSON, reqBody,nil,nil)
    if err != nil {
        return false
    }

    var res Result
    if err = json.Unmarshal(body, &res); err != nil {
        return false
    }
    return res.Success
}

func (api CameraRuleApi) SaveLinkRulesByGroup(reqBody map[string]interface{}) bool {
    url := api.getBasicUrl() + DATA_URL_PREFIX + "/camera/rule/saveLinkRulesByGroup"
    client := NewClient()
    body, err := client.DoPostRequest(url,CONTENT_TYPE_JSON, reqBody,nil,nil)
    if err != nil {
        return false
    }

    var res Result
    if err = json.Unmarshal(body, &res); err != nil {
        return false
    }
    return res.Success
}

func (api RuleTemplateApi) GetLinkRulesByCameraIds(reqBody map[string]interface{}) (bool,interface{}) {
    url := api.getBasicUrl() + DATA_URL_PREFIX + "/camera/rule/getLinkRulesByCameraIds"
    client := NewClient()
    body, err := client.DoPostRequest(url,CONTENT_TYPE_JSON, reqBody,nil,nil)
    if err != nil {
        return false,nil
    }

    var res Result
    if err = json.Unmarshal(body, &res); err != nil {
        return false,nil
    }
    return res.Success, res.Data
}

func (api CameraRuleApi) UpdateAlarmLevel(reqBody map[string]interface{}) bool {
    url := api.getBasicUrl() + DATA_URL_PREFIX + "/camera/rule/updateAlarmLevel"
    client := NewClient()
    body, err := client.DoPostRequest(url,CONTENT_TYPE_JSON, reqBody,nil,nil)
    if err != nil {
        return false
    }

    var res Result
    if err = json.Unmarshal(body, &res); err != nil {
        return false
    }
    return res.Success
}

func (api CameraRuleApi) DeleteByGroup(groupId string) bool {
    url := api.getBasicUrl() + DATA_URL_PREFIX + "/camera/rule/deleteByGroup"
    client := NewClient()
    paraM := map[string]string {
        "groupId": groupId,
    }
    body, err := client.DoGetRequest(url, paraM,nil)
    if err != nil {
        return false
    }

    var res Result
    if err = json.Unmarshal(body, &res); err != nil {
        return false
    }
    return res.Success
}

func (api CameraRuleApi) FindAll(groupId string) (flag bool,allRules []protomsg.CameraAndRules) {
    url := api.getBasicUrl() + DATA_URL_PREFIX + "/camera/rule/findAll"
    client := NewClient()
    body, err := client.DoGetRequest(url, nil,nil)
    if err != nil {
        return false,nil
    }

    var res Result
    if err = json.Unmarshal(body, &res); err != nil {
        return false,nil
    }
    if !res.Success {
        return false, nil
    }
    bytes, err := json.Marshal(res.Data)
    if err != nil {
        logPrint(err)
        return false, nil
    }
    err = json.Unmarshal(bytes, &allRules)
    if err != nil {
        logPrint(err)
        return false, nil
    }
    return true, allRules
}

 cameraTaskApi.go

@@ -1,190 +1,190 @@
package dbapi

import (
    "basic.com/pubsub/protomsg.git"
    "encoding/json"
    "strconv"
)

type CameraTaskApi struct {
    Ip string
    Port int
}

func (api CameraTaskApi) getBasicUrl() string {
    if api.Ip == "" {
        return BASIC_URL
    }
    if api.Ip == "" {
        api.Ip = DEFAULT_IP
    }
    if api.Port == 0 {
        api.Port = DEFAULT_PORT
    }
    return "http://"+api.Ip+":"+strconv.Itoa(api.Port)
}

func (api CameraTaskApi) FindAll() (b bool,list []protomsg.CameraTask) {
    url := api.getBasicUrl() + DATA_URL_PREFIX + "/cameraTask/findAll"
    client := NewClient()
    body, err := client.DoGetRequest(url, nil, nil)
    if err != nil {
        return false,nil
    }

    var res Result
    if err = json.Unmarshal(body, &res); err != nil {
        return false,nil
    }
    dataBytes, _ := json.Marshal(res.Data)
    if err := json.Unmarshal(dataBytes, &list);err !=nil {
        return false,nil
    }
    return true,list
}

func (api CameraTaskApi) AddTask(cameraId string,taskId string) (bool,interface{}) {
    url := api.getBasicUrl() + DATA_URL_PREFIX + "/cameraTask/addTask"
    client := NewClient()
    paramBody := map[string]interface{}{
        "cameraId": cameraId,
        "taskId": taskId,
    }
    respBody, err := client.DoPostRequest(url, CONTENT_TYPE_FORM, paramBody,nil,nil)
    if err != nil {
        return false,nil
    }
    var res Result
    if err = json.Unmarshal(respBody, &res); err != nil {
        return false,nil
    }
    return res.Success,res.Data
}

func (api CameraTaskApi) CameraTaskSave(paramBody map[string]interface{}) (bool,interface{}) {
    url := api.getBasicUrl() + DATA_URL_PREFIX + "/camera/saveTask"
    client := NewClient()
    respBody, err := client.DoPostRequest(url, CONTENT_TYPE_JSON, paramBody,nil, nil)
    if err != nil {
        return false,nil
    }
    var res Result
    if err = json.Unmarshal(respBody, &res); err != nil {
        return false,nil
    }
    return res.Success,res.Data
}

func (api CameraTaskApi) PasteRules(sourceId string, targetIds []string) bool {
    url := api.getBasicUrl() + DATA_URL_PREFIX + "/camera/pasteRules"
    client := NewClient()
    paramBody := map[string]interface{} {
        "sourceId": sourceId,
        "targetIds": targetIds,
    }
    respBody, err := client.DoPostRequest(url, CONTENT_TYPE_JSON, paramBody,nil, nil)
    if err != nil {
        return false
    }
    var res Result
    if err = json.Unmarshal(respBody, &res); err != nil {
        return false
    }
    return res.Success
}

func (api CameraTaskApi) FindTasksByCameraIds(cameraIds []string) (bool,interface{}) {
    url := api.getBasicUrl() + DATA_URL_PREFIX + "/camera/alltask"
    client := NewClient()
    paramBody :=make(map[string]interface{})
    paramBody["cameraIds"] = cameraIds
    respBody, err := client.DoPostRequest(url, CONTENT_TYPE_JSON, paramBody,nil, nil)
    if err != nil {
        return false,nil
    }
    var res Result
    if err = json.Unmarshal(respBody, &res); err != nil {
        return false,nil
    }
    return res.Success,res.Data
}

func (api CameraTaskApi) CameraTaskAll(cameraId string) (bool,interface{}) {
    url := api.getBasicUrl() + DATA_URL_PREFIX + "/camera/task/"+cameraId
    client := NewClient()
    paramQuery :=make(map[string]string)
    paramQuery["cameraId"] = cameraId
    respBody, err := client.DoGetRequest(url, paramQuery,nil)
    if err != nil {
        return false,nil
    }
    var res Result
    if err = json.Unmarshal(respBody, &res); err != nil {
        return false,nil
    }
    return res.Success,res.Data
}

func (api CameraTaskApi) DeleteCameraTask(cameraId string,taskId string) (bool,interface{}) {
    url := api.getBasicUrl() + DATA_URL_PREFIX + "/camera/delTask/"+cameraId+"/"+taskId
    client := NewClient()
    respBody, err := client.DoDeleteRequest(url, CONTENT_TYPE_FORM, nil,nil)
    if err != nil {
        return false,nil
    }
    var res Result
    if err = json.Unmarshal(respBody, &res); err != nil {
        return false,nil
    }
    return res.Success,res.Data
}

func (api CameraTaskApi) SaveIsDataTrans(paramBody map[string]interface{}) (bool,interface{}){
    url := api.getBasicUrl() + DATA_URL_PREFIX + "/cameraTask/saveIsDataTrans"
    client := NewClient()
    respBody, err := client.DoPostRequest(url, CONTENT_TYPE_JSON, paramBody,nil, nil)
    if err != nil {
        return false,nil
    }
    var res Result
    if err = json.Unmarshal(respBody, &res); err != nil {
        return false,nil
    }
    return res.Success,res.Data
}

func (api CameraTaskApi) SaveAlarmLevelByGroup(groupId string,alarmLevel int) (bool,interface{}){
    url := api.getBasicUrl() + DATA_URL_PREFIX + "/cameraTask/saveAlarmLevelByGroup"
    client := NewClient()
    paramBody :=make(map[string]interface{},0)
    paramBody["group_id"] = groupId
    paramBody["alarm_level"] = alarmLevel
    respBody, err := client.DoPostRequest(url, CONTENT_TYPE_JSON, paramBody,nil, nil)
    if err != nil {
        return false,nil
    }
    var res Result
    if err = json.Unmarshal(respBody, &res); err != nil {
        return false,nil
    }
    return res.Success,res.Data
}

//更新摄像机任务状态
func (api CameraTaskApi) UpdateCameraTaskStatus(cameraId string,taskId string,statusInt int) (bool,interface{}){
    url := api.getBasicUrl() + DATA_URL_PREFIX + "/cameraTask/updateCameraTaskStatus"
    client := NewClient()
    paramBody :=make(map[string]interface{})
    paramBody["cameraId"] = cameraId
    paramBody["taskId"] = taskId
    paramBody["status"] = statusInt
    respBody, err := client.DoPostRequest(url, CONTENT_TYPE_JSON, paramBody, nil, nil)
    if err != nil {
        return false,nil
    }
    var res Result
    if err = json.Unmarshal(respBody, &res); err != nil {
        return false,nil
    }
    return res.Success,res.Data
}
//
//import (
//    "basic.com/pubsub/protomsg.git"
//    "encoding/json"
//    "strconv"
//)
//
//type CameraTaskApi struct {
//    Ip string
//    Port int
//}
//
//func (api CameraTaskApi) getBasicUrl() string {
//    if api.Ip == "" {
//        return BASIC_URL
//    }
//    if api.Ip == "" {
//        api.Ip = DEFAULT_IP
//    }
//    if api.Port == 0 {
//        api.Port = DEFAULT_PORT
//    }
//    return "http://"+api.Ip+":"+strconv.Itoa(api.Port)
//}
//
//func (api CameraTaskApi) FindAll() (b bool,list []protomsg.CameraTask) {
//    url := api.getBasicUrl() + DATA_URL_PREFIX + "/cameraTask/findAll"
//    client := NewClient()
//    body, err := client.DoGetRequest(url, nil, nil)
//    if err != nil {
//        return false,nil
//    }
//
//    var res Result
//    if err = json.Unmarshal(body, &res); err != nil {
//        return false,nil
//    }
//    dataBytes, _ := json.Marshal(res.Data)
//    if err := json.Unmarshal(dataBytes, &list);err !=nil {
//        return false,nil
//    }
//    return true,list
//}
//
//func (api CameraTaskApi) AddTask(cameraId string,taskId string) (bool,interface{}) {
//    url := api.getBasicUrl() + DATA_URL_PREFIX + "/cameraTask/addTask"
//    client := NewClient()
//    paramBody := map[string]interface{}{
//        "cameraId": cameraId,
//        "taskId": taskId,
//    }
//    respBody, err := client.DoPostRequest(url, CONTENT_TYPE_FORM, paramBody,nil,nil)
//    if err != nil {
//        return false,nil
//    }
//    var res Result
//    if err = json.Unmarshal(respBody, &res); err != nil {
//        return false,nil
//    }
//    return res.Success,res.Data
//}
//
//func (api CameraTaskApi) CameraTaskSave(paramBody map[string]interface{}) (bool,interface{}) {
//    url := api.getBasicUrl() + DATA_URL_PREFIX + "/camera/saveTask"
//    client := NewClient()
//    respBody, err := client.DoPostRequest(url, CONTENT_TYPE_JSON, paramBody,nil, nil)
//    if err != nil {
//        return false,nil
//    }
//    var res Result
//    if err = json.Unmarshal(respBody, &res); err != nil {
//        return false,nil
//    }
//    return res.Success,res.Data
//}
//
//func (api CameraTaskApi) PasteRules(sourceId string, targetIds []string) bool {
//    url := api.getBasicUrl() + DATA_URL_PREFIX + "/camera/pasteRules"
//    client := NewClient()
//    paramBody := map[string]interface{} {
//        "sourceId": sourceId,
//        "targetIds": targetIds,
//    }
//    respBody, err := client.DoPostRequest(url, CONTENT_TYPE_JSON, paramBody,nil, nil)
//    if err != nil {
//        return false
//    }
//    var res Result
//    if err = json.Unmarshal(respBody, &res); err != nil {
//        return false
//    }
//    return res.Success
//}
//
//func (api CameraTaskApi) FindTasksByCameraIds(cameraIds []string) (bool,interface{}) {
//    url := api.getBasicUrl() + DATA_URL_PREFIX + "/camera/alltask"
//    client := NewClient()
//    paramBody :=make(map[string]interface{})
//    paramBody["cameraIds"] = cameraIds
//    respBody, err := client.DoPostRequest(url, CONTENT_TYPE_JSON, paramBody,nil, nil)
//    if err != nil {
//        return false,nil
//    }
//    var res Result
//    if err = json.Unmarshal(respBody, &res); err != nil {
//        return false,nil
//    }
//    return res.Success,res.Data
//}
//
//func (api CameraTaskApi) CameraTaskAll(cameraId string) (bool,interface{}) {
//    url := api.getBasicUrl() + DATA_URL_PREFIX + "/camera/task/"+cameraId
//    client := NewClient()
//    paramQuery :=make(map[string]string)
//    paramQuery["cameraId"] = cameraId
//    respBody, err := client.DoGetRequest(url, paramQuery,nil)
//    if err != nil {
//        return false,nil
//    }
//    var res Result
//    if err = json.Unmarshal(respBody, &res); err != nil {
//        return false,nil
//    }
//    return res.Success,res.Data
//}
//
//func (api CameraTaskApi) DeleteCameraTask(cameraId string,taskId string) (bool,interface{}) {
//    url := api.getBasicUrl() + DATA_URL_PREFIX + "/camera/delTask/"+cameraId+"/"+taskId
//    client := NewClient()
//    respBody, err := client.DoDeleteRequest(url, CONTENT_TYPE_FORM, nil,nil)
//    if err != nil {
//        return false,nil
//    }
//    var res Result
//    if err = json.Unmarshal(respBody, &res); err != nil {
//        return false,nil
//    }
//    return res.Success,res.Data
//}
//
//func (api CameraTaskApi) SaveIsDataTrans(paramBody map[string]interface{}) (bool,interface{}){
//    url := api.getBasicUrl() + DATA_URL_PREFIX + "/cameraTask/saveIsDataTrans"
//    client := NewClient()
//    respBody, err := client.DoPostRequest(url, CONTENT_TYPE_JSON, paramBody,nil, nil)
//    if err != nil {
//        return false,nil
//    }
//    var res Result
//    if err = json.Unmarshal(respBody, &res); err != nil {
//        return false,nil
//    }
//    return res.Success,res.Data
//}
//
//func (api CameraTaskApi) SaveAlarmLevelByGroup(groupId string,alarmLevel int) (bool,interface{}){
//    url := api.getBasicUrl() + DATA_URL_PREFIX + "/cameraTask/saveAlarmLevelByGroup"
//    client := NewClient()
//    paramBody :=make(map[string]interface{},0)
//    paramBody["group_id"] = groupId
//    paramBody["alarm_level"] = alarmLevel
//    respBody, err := client.DoPostRequest(url, CONTENT_TYPE_JSON, paramBody,nil, nil)
//    if err != nil {
//        return false,nil
//    }
//    var res Result
//    if err = json.Unmarshal(respBody, &res); err != nil {
//        return false,nil
//    }
//    return res.Success,res.Data
//}
//
////更新摄像机任务状态
//func (api CameraTaskApi) UpdateCameraTaskStatus(cameraId string,taskId string,statusInt int) (bool,interface{}){
//    url := api.getBasicUrl() + DATA_URL_PREFIX + "/cameraTask/updateCameraTaskStatus"
//    client := NewClient()
//    paramBody :=make(map[string]interface{})
//    paramBody["cameraId"] = cameraId
//    paramBody["taskId"] = taskId
//    paramBody["status"] = statusInt
//    respBody, err := client.DoPostRequest(url, CONTENT_TYPE_JSON, paramBody, nil, nil)
//    if err != nil {
//        return false,nil
//    }
//    var res Result
//    if err = json.Unmarshal(respBody, &res); err != nil {
//        return false,nil
//    }
//    return res.Success,res.Data
//}

 cameraTaskArgsApi.go

@@ -1,135 +1,135 @@
package dbapi

import (
    "basic.com/pubsub/protomsg.git"
    "encoding/json"
    "strconv"
)

type CameraTaskArgsApi struct {
    Ip string
    Port int
}

func (api CameraTaskArgsApi) getBasicUrl() string {
    if api.Ip == "" {
        return BASIC_URL
    }
    if api.Ip == "" {
        api.Ip = DEFAULT_IP
    }
    if api.Port == 0 {
        api.Port = DEFAULT_PORT
    }
    return "http://"+api.Ip+":"+strconv.Itoa(api.Port)
}

func (api CameraTaskArgsApi) FindByCameraAndTask(cameraId string,taskId string,setType string) (bool,interface{}) {
    url := api.getBasicUrl() + DATA_URL_PREFIX + "/camera/getRulesByCameraAndTask"
    client := NewClient()
    paramQuery :=make(map[string]string)
    paramQuery["cameraId"] = cameraId
    paramQuery["taskId"] = taskId
    paramQuery["set_type"] = setType
    respBody, err := client.DoGetRequest(url, paramQuery,nil)
    if err != nil {
        return false,nil
    }
    var res Result
    if err = json.Unmarshal(respBody, &res); err != nil {
        return false,nil
    }
    return res.Success,res.Data
}

func (api CameraTaskArgsApi) UpdateDefenceStateByGroup(groupId string,defenceState bool)(bool,interface{}){
    url := api.getBasicUrl() + DATA_URL_PREFIX + "/cameraTaskArgs/updateDefenceStateByGroup"
    client := NewClient()
    paramBody :=make(map[string]interface{},0)
    paramBody["groupId"] = groupId
    paramBody["defenceState"] = defenceState
    respBody, err := client.DoPostRequest(url,CONTENT_TYPE_FORM,paramBody,nil,nil)
    if err != nil {
        return false,nil
    }
    var res Result
    if err = json.Unmarshal(respBody, &res); err != nil {
        return false,nil
    }
    return res.Success,res.Data
}

func (api CameraTaskArgsApi) DeleteByGroup(groupId string)(bool,interface{}) {
    url := api.getBasicUrl() + DATA_URL_PREFIX + "/cameraTaskArgs/deleteByGroup"
    client := NewClient()
    paramQuery :=make(map[string]string)
    paramQuery["groupId"] = groupId
    respBody, err := client.DoGetRequest(url, paramQuery,nil)
    if err != nil {
        return false,nil
    }
    var res Result
    if err = json.Unmarshal(respBody, &res); err != nil {
        return false,nil
    }
    return res.Success,res.Data
}

func (api CameraTaskArgsApi) FindAll() ([]protomsg.CameraTaskArgs){
    url := api.getBasicUrl() + DATA_URL_PREFIX + "/cameraTaskArgs/findAll"
    client := NewClient()
    respBody, err := client.DoGetRequest(url, nil,nil)
    if err != nil {
        return nil
    }
    var res Result
    if err = json.Unmarshal(respBody, &res); err != nil {
        return nil
    }
    arr :=make([]protomsg.CameraTaskArgs,0)
    dataBytes, _ := json.Marshal(res.Data)
    json.Unmarshal(dataBytes,&arr)
    return arr
}

func (api CameraTaskArgsApi) GetLinkRulesByCameraIds(paramBody map[string]interface{})(bool,interface{}){
    url := api.getBasicUrl() + DATA_URL_PREFIX + "/cameraTaskArgs/getLinkRulesByCameraIds"
    client := NewClient()
    respBody, err := client.DoPostRequest(url,CONTENT_TYPE_JSON,paramBody,nil,nil)
    if err != nil {
        return false,nil
    }
    var res Result
    if err = json.Unmarshal(respBody, &res); err != nil {
        return false,nil
    }
    return res.Success,res.Data
}

func (api CameraTaskArgsApi) SaveLinkRulesByGroup(paramBody map[string]interface{}) (bool,interface{}){
    url := api.getBasicUrl() + DATA_URL_PREFIX + "/cameraTaskArgs/saveLinkRulesByGroup"
    client := NewClient()
    respBody, err := client.DoPostRequest(url, CONTENT_TYPE_JSON, paramBody,nil, nil)
    if err != nil {
        return false,nil
    }
    var res Result
    if err = json.Unmarshal(respBody, &res); err != nil {
        return false,nil
    }
    return res.Success,res.Data
}

func (api CameraTaskApi) RuleApply2All(paramBody map[string]interface{}) (bool,interface{}) {
    url := api.getBasicUrl() + DATA_URL_PREFIX + "/cameraTaskArgs/ruleApply2All"
    client := NewClient()
    respBody, err := client.DoPostRequest(url, CONTENT_TYPE_JSON, paramBody,nil, nil)
    if err != nil {
        return false,nil
    }
    var res Result
    if err = json.Unmarshal(respBody, &res); err != nil {
        return false,nil
    }
    return res.Success,res.Data
}
//
//import (
//    "basic.com/pubsub/protomsg.git"
//    "encoding/json"
//    "strconv"
//)
//
//type CameraTaskArgsApi struct {
//    Ip string
//    Port int
//}
//
//func (api CameraTaskArgsApi) getBasicUrl() string {
//    if api.Ip == "" {
//        return BASIC_URL
//    }
//    if api.Ip == "" {
//        api.Ip = DEFAULT_IP
//    }
//    if api.Port == 0 {
//        api.Port = DEFAULT_PORT
//    }
//    return "http://"+api.Ip+":"+strconv.Itoa(api.Port)
//}
//
//func (api CameraTaskArgsApi) FindByCameraAndTask(cameraId string,taskId string,setType string) (bool,interface{}) {
//    url := api.getBasicUrl() + DATA_URL_PREFIX + "/camera/getRulesByCameraAndTask"
//    client := NewClient()
//    paramQuery :=make(map[string]string)
//    paramQuery["cameraId"] = cameraId
//    paramQuery["taskId"] = taskId
//    paramQuery["set_type"] = setType
//    respBody, err := client.DoGetRequest(url, paramQuery,nil)
//    if err != nil {
//        return false,nil
//    }
//    var res Result
//    if err = json.Unmarshal(respBody, &res); err != nil {
//        return false,nil
//    }
//    return res.Success,res.Data
//}
//
//func (api CameraTaskArgsApi) UpdateDefenceStateByGroup(groupId string,defenceState bool)(bool,interface{}){
//    url := api.getBasicUrl() + DATA_URL_PREFIX + "/cameraTaskArgs/updateDefenceStateByGroup"
//    client := NewClient()
//    paramBody :=make(map[string]interface{},0)
//    paramBody["groupId"] = groupId
//    paramBody["defenceState"] = defenceState
//    respBody, err := client.DoPostRequest(url,CONTENT_TYPE_FORM,paramBody,nil,nil)
//    if err != nil {
//        return false,nil
//    }
//    var res Result
//    if err = json.Unmarshal(respBody, &res); err != nil {
//        return false,nil
//    }
//    return res.Success,res.Data
//}
//
//func (api CameraTaskArgsApi) DeleteByGroup(groupId string)(bool,interface{}) {
//    url := api.getBasicUrl() + DATA_URL_PREFIX + "/cameraTaskArgs/deleteByGroup"
//    client := NewClient()
//    paramQuery :=make(map[string]string)
//    paramQuery["groupId"] = groupId
//    respBody, err := client.DoGetRequest(url, paramQuery,nil)
//    if err != nil {
//        return false,nil
//    }
//    var res Result
//    if err = json.Unmarshal(respBody, &res); err != nil {
//        return false,nil
//    }
//    return res.Success,res.Data
//}
//
//func (api CameraTaskArgsApi) FindAll() ([]protomsg.CameraTaskArgs){
//    url := api.getBasicUrl() + DATA_URL_PREFIX + "/cameraTaskArgs/findAll"
//    client := NewClient()
//    respBody, err := client.DoGetRequest(url, nil,nil)
//    if err != nil {
//        return nil
//    }
//    var res Result
//    if err = json.Unmarshal(respBody, &res); err != nil {
//        return nil
//    }
//    arr :=make([]protomsg.CameraTaskArgs,0)
//    dataBytes, _ := json.Marshal(res.Data)
//    json.Unmarshal(dataBytes,&arr)
//    return arr
//}
//
//func (api CameraTaskArgsApi) GetLinkRulesByCameraIds(paramBody map[string]interface{})(bool,interface{}){
//    url := api.getBasicUrl() + DATA_URL_PREFIX + "/cameraTaskArgs/getLinkRulesByCameraIds"
//    client := NewClient()
//    respBody, err := client.DoPostRequest(url,CONTENT_TYPE_JSON,paramBody,nil,nil)
//    if err != nil {
//        return false,nil
//    }
//    var res Result
//    if err = json.Unmarshal(respBody, &res); err != nil {
//        return false,nil
//    }
//    return res.Success,res.Data
//}
//
//func (api CameraTaskArgsApi) SaveLinkRulesByGroup(paramBody map[string]interface{}) (bool,interface{}){
//    url := api.getBasicUrl() + DATA_URL_PREFIX + "/cameraTaskArgs/saveLinkRulesByGroup"
//    client := NewClient()
//    respBody, err := client.DoPostRequest(url, CONTENT_TYPE_JSON, paramBody,nil, nil)
//    if err != nil {
//        return false,nil
//    }
//    var res Result
//    if err = json.Unmarshal(respBody, &res); err != nil {
//        return false,nil
//    }
//    return res.Success,res.Data
//}
//
//func (api CameraTaskApi) RuleApply2All(paramBody map[string]interface{}) (bool,interface{}) {
//    url := api.getBasicUrl() + DATA_URL_PREFIX + "/cameraTaskArgs/ruleApply2All"
//    client := NewClient()
//    respBody, err := client.DoPostRequest(url, CONTENT_TYPE_JSON, paramBody,nil, nil)
//    if err != nil {
//        return false,nil
//    }
//    var res Result
//    if err = json.Unmarshal(respBody, &res); err != nil {
//        return false,nil
//    }
//    return res.Success,res.Data
//}

 ruleTemplateApi.go

New file
@@ -0,0 +1,101 @@
package dbapi

import (
    "basic.com/pubsub/protomsg.git"
    "encoding/json"
    "strconv"
)

type RuleTemplateApi struct{
    Ip string
    Port int
}

func (api RuleTemplateApi) getBasicUrl() string {
    if api.Ip == "" {
        return BASIC_URL
    }
    if api.Ip == "" {
        api.Ip = DEFAULT_IP
    }
    if api.Port == 0 {
        api.Port = DEFAULT_PORT
    }
    return "http://"+api.Ip+":"+strconv.Itoa(api.Port)
}

func (api RuleTemplateApi) Save(reqBody map[string]interface{}) bool {
    url := api.getBasicUrl() + DATA_URL_PREFIX + "/template/rule/save"
    client := NewClient()
    body, err := client.DoPostRequest(url,CONTENT_TYPE_JSON, reqBody,nil,nil)
    if err != nil {
        return false
    }

    var res Result
    if err = json.Unmarshal(body, &res); err != nil {
        return false
    }
    return res.Success
}

func (api RuleTemplateApi) Show(id string) (bool,interface{}) {
    url := api.getBasicUrl() + DATA_URL_PREFIX + "/template/rule/"+id
    client := NewClient()
    body, err := client.DoGetRequest(url, nil,nil)
    if err != nil {
        return false,nil
    }

    var res Result
    if err = json.Unmarshal(body, &res); err != nil {
        return false,nil
    }
    return res.Success, res.Data
}

func (api RuleTemplateApi) Delete(id string) bool {
    url := api.getBasicUrl() + DATA_URL_PREFIX + "/template/rule/"+id
    client := NewClient()
    body, err := client.DoDeleteRequest(url,CONTENT_TYPE_JSON, nil,nil)
    if err != nil {
        return false
    }

    var res Result
    if err = json.Unmarshal(body, &res); err != nil {
        return false
    }
    return res.Success
}

func (api RuleTemplateApi) FindAll() (b bool,templates []protomsg.RuleTemplate) {
    url := api.getBasicUrl() + DATA_URL_PREFIX + "/template/rule"
    client := NewClient()
    body, err := client.DoGetRequest(url,nil,nil)
    if err != nil {
        logPrint(err)
        return false,nil
    }

    var res Result
    if err = json.Unmarshal(body, &res); err != nil {
        logPrint(err)
        return false,nil
    }
    if !res.Success {
        logPrint(err)
        return false,nil
    }
    bytes,err := json.Marshal(res.Data)
    if err != nil {
        logPrint(err)
        return false, nil
    }
    err = json.Unmarshal(bytes, &templates)
    if err != nil {
        logPrint(err)
        return false, nil
    }
    return true, templates
}

 taskApi.go

@@ -1,198 +1,198 @@
package dbapi

import (
    "basic.com/pubsub/protomsg.git"
    "encoding/json"
    "strconv"
)

type TaskApi struct {
    Ip string
    Port int
}

func (api TaskApi) getBasicUrl() string {
    if api.Ip == "" {
        return BASIC_URL
    }
    if api.Ip == "" {
        api.Ip = DEFAULT_IP
    }
    if api.Port == 0 {
        api.Port = DEFAULT_PORT
    }
    return "http://"+api.Ip+":"+strconv.Itoa(api.Port)
}

//获取所有任务信息(包含算法定义)
func (api TaskApi) FindAll() (taskInfos []protomsg.TaskSdkInfo) {
    url := api.getBasicUrl() + DATA_URL_PREFIX + "/task/findAll"
    client := NewClient()

    respBody, err := client.DoGetRequest(url, nil, nil)
    if err !=nil {
        return taskInfos
    }
    var res Result
    if err = json.Unmarshal(respBody, &res); err != nil {
        logPrint(err)
        return taskInfos
    }
    bytes, _ := json.Marshal(res.Data)
    err = json.Unmarshal(bytes, &taskInfos)
    return taskInfos
}

func (api TaskApi) FindAllTaskDefaultArgs(scope string)(taskInfos []protomsg.TaskSdkInfo) {
    url := api.getBasicUrl() + DATA_URL_PREFIX + "/task/findAll"
    client := NewClient()
    queryParam := map[string]string {
        "scope": scope,
    }
    respBody, err := client.DoGetRequest(url, queryParam, nil)
    if err !=nil {
        return taskInfos
    }
    var res Result
    if err = json.Unmarshal(respBody, &res); err != nil {
        logPrint(err)
        return taskInfos
    }
    bytes, _ := json.Marshal(res.Data)
    err = json.Unmarshal(bytes, &taskInfos)
    return taskInfos
}

func (api TaskApi) FindAllTaskSdkRun() (taskSdks []protomsg.TaskSdkRun) {
    taskInfos := api.FindAll()
    if taskInfos !=nil {
        for _,ti :=range taskInfos{
            if !ti.Task.Enable {
                continue
            }
            tsr := protomsg.TaskSdkRun{
                Task:ti.Task,
            }
            m := make(map[string]string,0)
            for _,s := range ti.Sdks{
                if _,ok :=m[s.SdkType];!ok{
                    m[s.SdkType] = s.SdkType
                    tsr.Sdks = append(tsr.Sdks,&protomsg.SdkRun{
                        IpcId:s.IpcId,
                        SdkType:s.SdkType,
                    })
                }
            }

            taskSdks = append(taskSdks,tsr)
        }
    }
    return taskSdks
}

func (api TaskApi) Add(paramBody map[string]interface{}) (bool,interface{}) {
    url := api.getBasicUrl() + DATA_URL_PREFIX + "/task/addTask"
    client := NewClient()
    respBody, err := client.DoPostRequest(url, CONTENT_TYPE_JSON, paramBody, nil, nil)
    if err != nil {
        return false,nil
    }
    var res Result
    if err = json.Unmarshal(respBody, &res); err != nil {
        logPrint(err)
        return false,nil
    }
    return res.Success,res.Data
}

func (api TaskApi) Delete(taskId string) (bool,interface{}){
    url := api.getBasicUrl() + DATA_URL_PREFIX + "/task/delete"
    client := NewClient()
    paramQuery :=make(map[string]string,0)
    paramQuery["taskId"] = taskId
    respBody, err := client.DoGetRequest(url, paramQuery, nil)
    if err != nil {
        return false,nil
    }
    var res Result
    if err = json.Unmarshal(respBody, &res); err != nil {
        return false,nil
    }
    return res.Success,res.Data
}

func (api TaskApi) AddTaskSdk(paramBody map[string]interface{}) (bool,interface{}) {
    url := api.getBasicUrl() + DATA_URL_PREFIX + "/task/addTaskSdk"
    client := NewClient()
    respBody, err := client.DoPostRequest(url,CONTENT_TYPE_JSON, paramBody, nil,nil)
    if err != nil {
        return false,nil
    }
    var res Result
    if err = json.Unmarshal(respBody, &res); err != nil {
        return false,nil
    }
    return res.Success,res.Data
}

func (api TaskApi) UpdateTaskName(taskId string, taskName string) bool {
    url := api.getBasicUrl() + DATA_URL_PREFIX + "/task/updateTaskName"
    client := NewClient()
    paramBody := make(map[string]interface{},0)
    paramBody["taskId"] = taskId
    paramBody["taskName"] = taskName
    respBody, err := client.DoPostRequest(url, CONTENT_TYPE_FORM, paramBody, nil, nil)
    if err != nil {
        return false
    }
    var res Result
    if err = json.Unmarshal(respBody, &res); err != nil {
        return false
    }
    return res.Success
}

func (api TaskApi) UpdateTaskStatus(paramBody map[string]interface{}) (bool,interface{}) {
    url := api.getBasicUrl() + DATA_URL_PREFIX + "/task/updateTaskStatus"
    client := NewClient()
    respBody, err := client.DoPostRequest(url, CONTENT_TYPE_JSON, paramBody, nil, nil)
    if err != nil {
        return false,nil
    }
    var res Result
    if err = json.Unmarshal(respBody, &res); err != nil {
        return false,nil
    }
    return res.Success,res.Data
}

func (api TaskApi) DeleteTaskSdk(taskId string,sdkId string) (bool,interface{}) {
    url := api.getBasicUrl() + DATA_URL_PREFIX + "/task/delTaskSdk"
    client := NewClient()
    paramQuery :=make(map[string]string,0)
    paramQuery["taskId"] = taskId
    paramQuery["sdkId"] = sdkId
    respBody, err := client.DoGetRequest(url, paramQuery, nil)
    if err != nil {
        return false,nil
    }
    var res Result
    if err = json.Unmarshal(respBody, &res); err != nil {
        return false,nil
    }
    return res.Success,res.Data
}

func (api TaskApi) StatisticTaskCamera() (bool,interface{}) {
    url := api.getBasicUrl() + DATA_URL_PREFIX + "/task/statisticTaskCamera"
    client := NewClient()
    respBody, err := client.DoGetRequest(url, nil, nil)
    if err != nil {
        return false,nil
    }
    var res Result
    if err = json.Unmarshal(respBody, &res); err != nil {
        return false,nil
    }
    return res.Success,res.Data
}
//
//import (
//    "basic.com/pubsub/protomsg.git"
//    "encoding/json"
//    "strconv"
//)
//
//type TaskApi struct {
//    Ip string
//    Port int
//}
//
//func (api TaskApi) getBasicUrl() string {
//    if api.Ip == "" {
//        return BASIC_URL
//    }
//    if api.Ip == "" {
//        api.Ip = DEFAULT_IP
//    }
//    if api.Port == 0 {
//        api.Port = DEFAULT_PORT
//    }
//    return "http://"+api.Ip+":"+strconv.Itoa(api.Port)
//}
//
////获取所有任务信息(包含算法定义)
//func (api TaskApi) FindAll() (taskInfos []protomsg.TaskSdkInfo) {
//    url := api.getBasicUrl() + DATA_URL_PREFIX + "/task/findAll"
//    client := NewClient()
//
//    respBody, err := client.DoGetRequest(url, nil, nil)
//    if err !=nil {
//        return taskInfos
//    }
//    var res Result
//    if err = json.Unmarshal(respBody, &res); err != nil {
//        logPrint(err)
//        return taskInfos
//    }
//    bytes, _ := json.Marshal(res.Data)
//    err = json.Unmarshal(bytes, &taskInfos)
//    return taskInfos
//}
//
//func (api TaskApi) FindAllTaskDefaultArgs(scope string)(taskInfos []protomsg.TaskSdkInfo) {
//    url := api.getBasicUrl() + DATA_URL_PREFIX + "/task/findAll"
//    client := NewClient()
//    queryParam := map[string]string {
//        "scope": scope,
//    }
//    respBody, err := client.DoGetRequest(url, queryParam, nil)
//    if err !=nil {
//        return taskInfos
//    }
//    var res Result
//    if err = json.Unmarshal(respBody, &res); err != nil {
//        logPrint(err)
//        return taskInfos
//    }
//    bytes, _ := json.Marshal(res.Data)
//    err = json.Unmarshal(bytes, &taskInfos)
//    return taskInfos
//}
//
//func (api TaskApi) FindAllTaskSdkRun() (taskSdks []protomsg.TaskSdkRun) {
//    taskInfos := api.FindAll()
//    if taskInfos !=nil {
//        for _,ti :=range taskInfos{
//            if !ti.Task.Enable {
//                continue
//            }
//            tsr := protomsg.TaskSdkRun{
//                Task:ti.Task,
//            }
//            m := make(map[string]string,0)
//            for _,s := range ti.Sdks{
//                if _,ok :=m[s.SdkType];!ok{
//                    m[s.SdkType] = s.SdkType
//                    tsr.Sdks = append(tsr.Sdks,&protomsg.SdkRun{
//                        IpcId:s.IpcId,
//                        SdkType:s.SdkType,
//                    })
//                }
//            }
//
//            taskSdks = append(taskSdks,tsr)
//        }
//    }
//    return taskSdks
//}
//
//func (api TaskApi) Add(paramBody map[string]interface{}) (bool,interface{}) {
//    url := api.getBasicUrl() + DATA_URL_PREFIX + "/task/addTask"
//    client := NewClient()
//    respBody, err := client.DoPostRequest(url, CONTENT_TYPE_JSON, paramBody, nil, nil)
//    if err != nil {
//        return false,nil
//    }
//    var res Result
//    if err = json.Unmarshal(respBody, &res); err != nil {
//        logPrint(err)
//        return false,nil
//    }
//    return res.Success,res.Data
//}
//
//func (api TaskApi) Delete(taskId string) (bool,interface{}){
//    url := api.getBasicUrl() + DATA_URL_PREFIX + "/task/delete"
//    client := NewClient()
//    paramQuery :=make(map[string]string,0)
//    paramQuery["taskId"] = taskId
//    respBody, err := client.DoGetRequest(url, paramQuery, nil)
//    if err != nil {
//        return false,nil
//    }
//    var res Result
//    if err = json.Unmarshal(respBody, &res); err != nil {
//        return false,nil
//    }
//    return res.Success,res.Data
//}
//
//func (api TaskApi) AddTaskSdk(paramBody map[string]interface{}) (bool,interface{}) {
//    url := api.getBasicUrl() + DATA_URL_PREFIX + "/task/addTaskSdk"
//    client := NewClient()
//    respBody, err := client.DoPostRequest(url,CONTENT_TYPE_JSON, paramBody, nil,nil)
//    if err != nil {
//        return false,nil
//    }
//    var res Result
//    if err = json.Unmarshal(respBody, &res); err != nil {
//        return false,nil
//    }
//    return res.Success,res.Data
//}
//
//func (api TaskApi) UpdateTaskName(taskId string, taskName string) bool {
//    url := api.getBasicUrl() + DATA_URL_PREFIX + "/task/updateTaskName"
//    client := NewClient()
//    paramBody := make(map[string]interface{},0)
//    paramBody["taskId"] = taskId
//    paramBody["taskName"] = taskName
//    respBody, err := client.DoPostRequest(url, CONTENT_TYPE_FORM, paramBody, nil, nil)
//    if err != nil {
//        return false
//    }
//    var res Result
//    if err = json.Unmarshal(respBody, &res); err != nil {
//        return false
//    }
//    return res.Success
//}
//
//func (api TaskApi) UpdateTaskStatus(paramBody map[string]interface{}) (bool,interface{}) {
//    url := api.getBasicUrl() + DATA_URL_PREFIX + "/task/updateTaskStatus"
//    client := NewClient()
//    respBody, err := client.DoPostRequest(url, CONTENT_TYPE_JSON, paramBody, nil, nil)
//    if err != nil {
//        return false,nil
//    }
//    var res Result
//    if err = json.Unmarshal(respBody, &res); err != nil {
//        return false,nil
//    }
//    return res.Success,res.Data
//}
//
//func (api TaskApi) DeleteTaskSdk(taskId string,sdkId string) (bool,interface{}) {
//    url := api.getBasicUrl() + DATA_URL_PREFIX + "/task/delTaskSdk"
//    client := NewClient()
//    paramQuery :=make(map[string]string,0)
//    paramQuery["taskId"] = taskId
//    paramQuery["sdkId"] = sdkId
//    respBody, err := client.DoGetRequest(url, paramQuery, nil)
//    if err != nil {
//        return false,nil
//    }
//    var res Result
//    if err = json.Unmarshal(respBody, &res); err != nil {
//        return false,nil
//    }
//    return res.Success,res.Data
//}
//
//func (api TaskApi) StatisticTaskCamera() (bool,interface{}) {
//    url := api.getBasicUrl() + DATA_URL_PREFIX + "/task/statisticTaskCamera"
//    client := NewClient()
//    respBody, err := client.DoGetRequest(url, nil, nil)
//    if err != nil {
//        return false,nil
//    }
//    var res Result
//    if err = json.Unmarshal(respBody, &res); err != nil {
//        return false,nil
//    }
//    return res.Success,res.Data
//}

 taskSdkRuleApi.go

@@ -1,103 +1,103 @@
package dbapi

import (
    "basic.com/pubsub/protomsg.git"
    "encoding/json"
    "strconv"
)

type TaskSdkRuleApi struct {
    Ip string
    Port int
}

func (api TaskSdkRuleApi) getBasicUrl() string {
    if api.Ip == "" {
        return BASIC_URL
    }
    if api.Ip == "" {
        api.Ip = DEFAULT_IP
    }
    if api.Port == 0 {
        api.Port = DEFAULT_PORT
    }
    return "http://"+api.Ip+":"+strconv.Itoa(api.Port)
}

func (api TaskSdkRuleApi) FindAllTaskSdkRules() (b bool,rules []protomsg.TaskSdkRule){
    url := api.getBasicUrl() + DATA_URL_PREFIX + "/task/findAllTaskSdkRules"
    client := NewClient()
    body, err := client.DoGetRequest(url, nil, nil)
    if err != nil {
        return false,nil
    }

    var res Result
    if err = json.Unmarshal(body, &res); err != nil {
        logPrint(err)
        return false,nil
    }
    bytes, _ := json.Marshal(res.Data)
    err = json.Unmarshal(bytes, &rules)
    if err !=nil{
        return false,nil
    }
    return res.Success,rules
}

func (api TaskSdkRuleApi) GetRulesByTaskSdk(taskId string,sdkId string) (bool,interface{}){
    url := api.getBasicUrl() + DATA_URL_PREFIX + "/task/getRulesByTaskSdk"
    client := NewClient()
    paramQ := make(map[string]string,0)
    paramQ["taskId"] = taskId
    paramQ["sdkId"] = sdkId
    body, err := client.DoGetRequest(url, paramQ, nil)
    if err != nil {
        return false,err
    }

    var res Result
    if err = json.Unmarshal(body, &res); err != nil {
        logPrint(err)
        return false,err
    }
    return res.Success,res.Data
}

func (api TaskSdkRuleApi) DeleteTaskSdkRule(taskId string,sdkId string) bool{
    url := api.getBasicUrl() + DATA_URL_PREFIX + "/task/deleteTaskSdkRule"
    client := NewClient()
    paramBody := map[string]interface{}{
        "taskId": taskId,
        "sdkId": sdkId,
    }
    body,err := client.DoPostRequest(url,CONTENT_TYPE_FORM, paramBody,nil,nil)
    if err != nil {
        return false
    }

    var res Result
    if err = json.Unmarshal(body, &res); err != nil {
        logPrint(err)
        return false
    }

    return res.Success
}

func (api TaskSdkRuleApi) SaveTaskSdkRule(paramBody map[string]interface{}) (bool,interface{}) {
    url := api.getBasicUrl() + DATA_URL_PREFIX + "/task/saveTaskSdkRule"
    client := NewClient()
    body,err := client.DoPostRequest(url,CONTENT_TYPE_JSON, paramBody,nil,nil)
    if err != nil {
        return false,nil
    }

    var res Result
    if err = json.Unmarshal(body, &res); err != nil {
        logPrint(err)
        return false,nil
    }

    return res.Success,res.Data
}
//
//import (
//    "basic.com/pubsub/protomsg.git"
//    "encoding/json"
//    "strconv"
//)
//
//type TaskSdkRuleApi struct {
//    Ip string
//    Port int
//}
//
//func (api TaskSdkRuleApi) getBasicUrl() string {
//    if api.Ip == "" {
//        return BASIC_URL
//    }
//    if api.Ip == "" {
//        api.Ip = DEFAULT_IP
//    }
//    if api.Port == 0 {
//        api.Port = DEFAULT_PORT
//    }
//    return "http://"+api.Ip+":"+strconv.Itoa(api.Port)
//}
//
//func (api TaskSdkRuleApi) FindAllTaskSdkRules() (b bool,rules []protomsg.TaskSdkRule){
//    url := api.getBasicUrl() + DATA_URL_PREFIX + "/task/findAllTaskSdkRules"
//    client := NewClient()
//    body, err := client.DoGetRequest(url, nil, nil)
//    if err != nil {
//        return false,nil
//    }
//
//    var res Result
//    if err = json.Unmarshal(body, &res); err != nil {
//        logPrint(err)
//        return false,nil
//    }
//    bytes, _ := json.Marshal(res.Data)
//    err = json.Unmarshal(bytes, &rules)
//    if err !=nil{
//        return false,nil
//    }
//    return res.Success,rules
//}
//
//func (api TaskSdkRuleApi) GetRulesByTaskSdk(taskId string,sdkId string) (bool,interface{}){
//    url := api.getBasicUrl() + DATA_URL_PREFIX + "/task/getRulesByTaskSdk"
//    client := NewClient()
//    paramQ := make(map[string]string,0)
//    paramQ["taskId"] = taskId
//    paramQ["sdkId"] = sdkId
//    body, err := client.DoGetRequest(url, paramQ, nil)
//    if err != nil {
//        return false,err
//    }
//
//    var res Result
//    if err = json.Unmarshal(body, &res); err != nil {
//        logPrint(err)
//        return false,err
//    }
//    return res.Success,res.Data
//}
//
//func (api TaskSdkRuleApi) DeleteTaskSdkRule(taskId string,sdkId string) bool{
//    url := api.getBasicUrl() + DATA_URL_PREFIX + "/task/deleteTaskSdkRule"
//    client := NewClient()
//    paramBody := map[string]interface{}{
//        "taskId": taskId,
//        "sdkId": sdkId,
//    }
//    body,err := client.DoPostRequest(url,CONTENT_TYPE_FORM, paramBody,nil,nil)
//    if err != nil {
//        return false
//    }
//
//    var res Result
//    if err = json.Unmarshal(body, &res); err != nil {
//        logPrint(err)
//        return false
//    }
//
//    return res.Success
//}
//
//func (api TaskSdkRuleApi) SaveTaskSdkRule(paramBody map[string]interface{}) (bool,interface{}) {
//    url := api.getBasicUrl() + DATA_URL_PREFIX + "/task/saveTaskSdkRule"
//    client := NewClient()
//    body,err := client.DoPostRequest(url,CONTENT_TYPE_JSON, paramBody,nil,nil)
//    if err != nil {
//        return false,nil
//    }
//
//    var res Result
//    if err = json.Unmarshal(body, &res); err != nil {
//        logPrint(err)
//        return false,nil
//    }
//
//    return res.Success,res.Data
//}