cameraTaskArgs with vue

liuxiaolong

2019-06-12 f0d5b15c56a7416b8636e4e68ef28179a05812e3

cameraTaskArgs with vue

 api_test.go

@@ -1,9 +1,10 @@
package dbapi

import (
    "basic.com/pubsub/protomsg.git"
    "analyweb/protomsg"
    "fmt"
    "testing"
    "time"
)

func TestGetLocalCameraTree(t *testing.T) {
@@ -52,15 +53,20 @@
}

func TestSdkApi_Save(t *testing.T) {
    for {
        time.Sleep(10 * time.Second)
    var api SdkApi
    sdk := protomsg.Sdk{
        SdkName:"测试sdk啊啊啊啊啊",

            SdkName:"awfewagewag",
            Icon:"bbb",
            Url:"baidu",
    }
    result := api.Save(sdk)
    fmt.Println("add result: ",result)
}

}

func TestMangosReqClient(t *testing.T){

}

 areaApi.go

@@ -3,7 +3,6 @@
import (
    "encoding/json"
    "fmt"
    "basic.com/pubsub/protomsg.git"
)

type AreaApi struct {
@@ -12,15 +11,15 @@
//parentId 要查寻的目录树的根节点id
//searchType(0:全部，1:分析摄像机,2:监控摄像机)
//cameraName（摄像机名称）
func (api AreaApi) GetLocalCameraTree(parentId int, searchType int, cameraName string) []TreeMenu {
func (api AreaApi) GetLocalCameraTree(parentId string, searchType string, cameraName string) []TreeMenu {
    var result []TreeMenu

    client := NewClient()

    url := BASIC_URL + DATA_URL_PREFIX + "/area/localmenu"
    params := make(map[string]string, 0)
    params["parentId"] = string(parentId)
    params["searchType"] = string(searchType)
    params["parentId"] = parentId
    params["searchType"] = searchType
    params["cameraName"] = cameraName

    respBody, err := client.DoGetRequest(url, params, nil)
@@ -42,11 +41,10 @@
}

//添加目录节点
func (api AreaApi) AreaAdd(area protomsg.Area) bool {
func (api AreaApi) AreaAdd(paramBody map[string]interface{}) bool {
    flag := false
    url := BASIC_URL + DATA_URL_PREFIX + "/area/add"
    client := NewClient()
    paramBody := Struct2Map(area)
    respBody, err := client.DoPostRequest(url, CONTENT_TYPE_FORM, paramBody, nil, nil)
    if err != nil {
        return flag
@@ -61,15 +59,11 @@
}

//目录更新
func (api AreaApi) AreaUpdate(area protomsg.Area) bool {
func (api AreaApi) AreaUpdate(paramBody map[string]interface{}) bool {
    flag := false
    url := BASIC_URL + DATA_URL_PREFIX + "/area/update/" + string(area.Id)
    url := BASIC_URL + DATA_URL_PREFIX + "/area/update/" + paramBody["id"].(string)
    client := NewClient()

    if area.Name == "" || area.Id == 0 {
        return flag
    }
    paramBody := Struct2Map(area)
    respBody, err := client.DoPutRequest(url, CONTENT_TYPE_JSON, paramBody, nil)
    if err != nil {
        return flag

 cameraApi.go

@@ -1,20 +1,49 @@
package dbapi

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

type CameraApi struct{}

func (api CameraApi) CameraAdd(camera protomsg.Camera) bool {
func (api CameraApi) CameraAdd(paramBody map[string]interface{}) bool {
    url := BASIC_URL + DATA_URL_PREFIX + "/camera/add"
    client := NewClient()
    bodyParam := make(map[string]interface{},0)
    bodyParam["name"]=camera.Name
    bodyParam["areaid"] = camera.Areaid
    body, err := client.DoPostRequest(url,CONTENT_TYPE_JSON,bodyParam,nil,nil)
    body, err := client.DoPostRequest(url,CONTENT_TYPE_JSON,paramBody,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 CameraApi) CameraUpdate(paramBody map[string]interface{}) bool {
    url := BASIC_URL + DATA_URL_PREFIX + "/camera/update"
    client := NewClient()
    body, err := client.DoPutRequest(url,CONTENT_TYPE_JSON,paramBody,nil)
    if err != nil {
        return false
    }

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

func (api CameraApi) CameraDelete(cid string) bool {
    url := BASIC_URL + DATA_URL_PREFIX + "/camera/delete/"+cid
    client := NewClient()
    paramMap := make(map[string]string,0)
    paramMap["cid"] = cid
    body, err := client.DoDeleteRequest(url,CONTENT_TYPE_FORM,nil,paramMap)
    if err != nil {
        return false
    }
@@ -27,25 +56,24 @@
}

//通过cameraId获取摄像机信息
func (api CameraApi) GetCameraById(cameraId string) (result protomsg.Camera, err error) {
func (api CameraApi) GetCameraById(cameraId string) (camera protomsg.Camera, err error) {
    url := BASIC_URL + DATA_URL_PREFIX + "/camera/show/" + cameraId
    client := NewClient()

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

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

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

    return result, err
    return camera, err
}

func (api CameraApi) FindAll() (cameras []protomsg.Camera) {
@@ -90,3 +118,159 @@

    return cameraTasks
}

func (api CameraApi) SaveCameraPolygon(paramBody map[string]interface{}) (bool,interface{}) {
    url := BASIC_URL + DATA_URL_PREFIX + "/polygon/save"
    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 {
        fmt.Println(err)
        return false,nil
    }

    return res.Success,res.Data
}

func (api CameraApi) DeleteCameraPolygon(id string) (bool,interface{}){
    url := BASIC_URL + DATA_URL_PREFIX + "/polygon/delete"
    client := NewClient()
    paramQuery := make(map[string]string,0)
    paramQuery["id"]=id
    body, err := client.DoGetRequest(url, paramQuery, 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 CameraApi) FindPolygonsByCameraId(cameraId string) (bool,interface{}) {
    url := BASIC_URL + DATA_URL_PREFIX + "/polygon/findByCameraId"
    client := NewClient()
    paramQuery := make(map[string]string,0)
    paramQuery["cameraId"] = cameraId
    body, err := client.DoGetRequest(url, paramQuery, nil)
    if err != nil {
        return false,nil
    }

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

//新增或更新时间规则
func (api CameraApi) SaveCameraTimerule(paramBody map[string]interface{}) (bool,interface{}) {
    url := BASIC_URL + DATA_URL_PREFIX + "/cameraTimerule/save"
    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 {
        fmt.Println(err)
        return false,nil
    }

    return res.Success,res.Data
}

func (api CameraApi) DeleteCameraTimerule (id string) bool {
    url := BASIC_URL + DATA_URL_PREFIX + "/cameraTimerule/delete"
    client := NewClient()
    paramQuery := make(map[string]string,0)
    paramQuery["id"]=id
    body, err := client.DoGetRequest(url, paramQuery, nil)
    if err != nil {
        return false
    }

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

//根据摄像机id查找所有的时间规则
func (api CameraApi) FindAllTimeRules() (flag bool,data interface{}) {
    url := BASIC_URL + DATA_URL_PREFIX + "/cameraTimerule/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
    }
    return true,res.Data
}

// @Summary 根据多边形id更新布撤防状态
// @Description  根据多边形id更新布撤防状态
// @Produce json
// @Tags 摄像机多边形
// @Param  polygonId query string true "多边形id"
// @Param  defence_state query int true "布撤防状态(0:撤销，1：布防)"
// @Success 200 {string} json "{"code":200, success:true, msg:"", data:""}"
// @Failure 500 {string} json "{"code":500, success:false, msg:"", data:""}"
// @Router /data/api-v/polygon/updateDefenceStateByPolygonId [get]
func (api CameraApi) UpdateDefenceStateByPolygonId(polygonId string,state string) (bool,interface{}){
    url := BASIC_URL + DATA_URL_PREFIX + "/polygon/updateDefenceStateByPolygonId"
    client := NewClient()
    paramQuery :=make(map[string]string,0)
    paramQuery["polygonId"] = polygonId
    paramQuery["defence_state"]=state
    body, err := client.DoGetRequest(url, paramQuery, nil)
    if err != nil {
        return false,nil
    }

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

// @Summary 根据摄像机id更新布撤防状态
// @Description  根据摄像机id更新布撤防状态
// @Produce json
// @Tags 摄像机多边形
// @Param  cameraId query string true "摄像机id"
// @Param  defence_state query int true "布撤防状态(0:撤销，1：布防)"
// @Success 200 {string} json "{"code":200, success:true, msg:"", data:""}"
// @Failure 500 {string} json "{"code":500, success:false, msg:"", data:""}"
// @Router /data/api-v/polygon/updateDefenceStateByCameraId [get]
func (api CameraApi) UpdateDefenceStateByCameraId(cameraId string,state string) (bool,interface{}){
    url := BASIC_URL + DATA_URL_PREFIX + "/polygon/updateDefenceStateByCameraId"
    client := NewClient()
    paramQuery :=make(map[string]string,0)
    paramQuery["cameraId"] = cameraId
    paramQuery["defence_state"]=state
    body, err := client.DoGetRequest(url, paramQuery, nil)
    if err != nil {
        return false,nil
    }

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

 cameraTaskApi.go

@@ -1 +1,81 @@
package dbapi

import "encoding/json"

type CameraTaskApi struct {

}

func (api CameraTaskApi) CameraTaskSave(paramBody map[string]interface{}) (bool,interface{}) {
    url := BASIC_URL + 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) FindTasksByCameraIds(cameraIds []string) (bool,interface{}) {
    url := BASIC_URL + 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 := BASIC_URL + 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 := BASIC_URL + DATA_URL_PREFIX + "/camera/delTask/"+cameraId+"/"+taskId
    client := NewClient()
    respBody, err := client.DoPutRequest(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) SaveTransAndAlarmLevel(paramBody map[string]interface{}) (bool,interface{}){
    url := BASIC_URL + DATA_URL_PREFIX + "/cameraTask/saveTransAndAlarmLevel"
    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
}

 cameraTaskArgsApi.go

@@ -1 +1,41 @@
package dbapi

import "encoding/json"

type CameraTaskArgsApi struct {

}

func (api CameraTaskArgsApi) FindByCameraAndTask(cameraId string,taskId string,setType string) (bool,interface{}) {
    url := BASIC_URL + 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) DeleteByGroup(groupId string)(bool,interface{}) {
    url := BASIC_URL + 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
}

 client.go

@@ -11,7 +11,7 @@
    DoDeleteRequest(url string, contentType string, body map[string]interface{}, headers map[string]string) ([]byte, error)
}

var BASIC_URL            = "http://192.168.1.11:8001"
var BASIC_URL            = "http://127.0.0.1:8001"

const (
    DATA_URL_PREFIX      = "/data/api-v"

 clientFactory.go

@@ -2,5 +2,8 @@

//Factory new client
func NewClient() Client {
    return &HttpClient{}
    var client Client
    client = &HttpClient{}
    //client = &ReqRepClient{}
    return client
}

 dicApi.go

@@ -1 +1,27 @@
package dbapi

import (
    "encoding/json"
    "fmt"
)

type DicApi struct {

}

func (api DicApi) FindByType(dicType string) (bool,interface{}) {
    url := BASIC_URL + DATA_URL_PREFIX + "/dictionary/findByType"
    client := NewClient()
    paramMap := make(map[string]string)
    paramMap["type"] = dicType
    respBody, err := client.DoGetRequest(url, paramMap, nil)
    if err !=nil {
        return false,nil
    }
    var res Result
    if err = json.Unmarshal(respBody, &res); err != nil {
        fmt.Println(err)
        return false,nil
    }
    return res.Success,res.Data
}

 reqrepClient.go

@@ -1,69 +1,63 @@
package dbapi

import (
    "basic.com/valib/deliver.git"
    "encoding/json"
    "errors"
)

type ReqRepClient struct {}

var ReqRep_URL = "tcp://192.168.1.11:8002"

//初始化rply的地址
func InitRplyUrl(url string) {
    ReqRep_URL = url
}

func (api ReqRepClient) DoGetRequest(url string, params map[string]string, headers map[string]string) ([]byte, error) {
    var reqBody RplyParamBody
    reqBody.Action = url
    var destMap map[string]interface{}
    for idx,val := range params {
        destMap[idx] = interface{}(val)
    }
    reqBody.Params = destMap
    return doRply(reqBody)
}

func (api ReqRepClient) DoPostRequest(url string, contentType string, body map[string]interface{}, params map[string]string, headers map[string]string) ([]byte, error) {
    var reqBody RplyParamBody
    reqBody.Action = url
    reqBody.Params = body
    return doRply(reqBody)
}

func (api ReqRepClient) DoPutRequest(url string, contentType string, body map[string]interface{}, headers map[string]string) ([]byte, error) {
    var reqBody RplyParamBody
    reqBody.Action = url
    reqBody.Params = body
    return doRply(reqBody)
}

func (api ReqRepClient) DoDeleteRequest(url string, contentType string, body map[string]interface{}, headers map[string]string) ([]byte, error) {
    var reqBody RplyParamBody
    reqBody.Action = url
    reqBody.Params = body
    return doRply(reqBody)
}

type RplyParamBody struct {
    Action string    `json:"action"`    //根据action判断做何种响应
    Params map[string]interface{}    `json:"params"`//参数map
}

func doRply(body RplyParamBody)([]byte,error){
    sender := deliver.NewClient(deliver.Mode(deliver.ReqRep), ReqRep_URL)
    bytes,err := json.Marshal(body)
    if err !=nil {
        return nil,err
    }
    err = sender.Send(bytes)
    if err !=nil {
        resMsg, _ := sender.Recv()
        if resMsg !=nil {
            return resMsg,nil
        }
    }
    return nil,errors.New("nng no resp")
}
//var ReqRep_URL = "tcp://192.168.1.11:8002"
//
////初始化rply的地址
//func InitRplyUrl(url string) {
//    ReqRep_URL = url
//}
//
//func (api ReqRepClient) DoGetRequest(url string, params map[string]string, headers map[string]string) ([]byte, error) {
//    var reqBody RplyParamBody
//    reqBody.Action = url
//    var destMap map[string]interface{}
//    for idx,val := range params {
//        destMap[idx] = interface{}(val)
//    }
//    reqBody.Params = destMap
//    return doRply(reqBody)
//}
//
//func (api ReqRepClient) DoPostRequest(url string, contentType string, body map[string]interface{}, params map[string]string, headers map[string]string) ([]byte, error) {
//    var reqBody RplyParamBody
//    reqBody.Action = url
//    reqBody.Params = body
//    return doRply(reqBody)
//}
//
//func (api ReqRepClient) DoPutRequest(url string, contentType string, body map[string]interface{}, headers map[string]string) ([]byte, error) {
//    var reqBody RplyParamBody
//    reqBody.Action = url
//    reqBody.Params = body
//    return doRply(reqBody)
//}
//
//func (api ReqRepClient) DoDeleteRequest(url string, contentType string, body map[string]interface{}, headers map[string]string) ([]byte, error) {
//    var reqBody RplyParamBody
//    reqBody.Action = url
//    reqBody.Params = body
//    return doRply(reqBody)
//}
//
//type RplyParamBody struct {
//    Action string    `json:"action"`    //根据action判断做何种响应
//    Params map[string]interface{}    `json:"params"`//参数map
//}
//
//func doRply(body RplyParamBody)([]byte,error){
//    sender := deliver.NewClient(deliver.Mode(deliver.ReqRep), ReqRep_URL)
//    bytes,err := json.Marshal(body)
//    if err !=nil {
//        return nil,err
//    }
//    err = sender.Send(bytes)
//    if err !=nil {
//        resMsg, _ := sender.Recv()
//        if resMsg !=nil {
//            return resMsg,nil
//        }
//    }
//    return nil,errors.New("nng no resp")
//}

 sdkApi.go

@@ -1,7 +1,7 @@
package dbapi

import (
    "basic.com/pubsub/protomsg.git"
    "analyweb/protomsg"
    "encoding/json"
    "fmt"
)
@@ -10,22 +10,20 @@
}

//保存算法，新增(算法id为空)，更新（算法id不为空）
func (api SdkApi)Save(sdk protomsg.Sdk)bool {
func (api SdkApi)Save(paramBody map[string]interface{}) (bool,interface{}) {
    flag := false
    url := BASIC_URL + DATA_URL_PREFIX + "/sdk/save"
    url := BASIC_URL + DATA_URL_PREFIX + "/sdk/saveSdk"
    client := NewClient()
    paramBody := Struct2Map(sdk)
    respBody, err := client.DoPostRequest(url, CONTENT_TYPE_FORM, paramBody, nil, nil)
    respBody, err := client.DoPostRequest(url, CONTENT_TYPE_JSON, paramBody, nil, nil)
    if err != nil {
        return flag
        return flag,nil
    }
    var res Result
    if err = json.Unmarshal(respBody, &res); err != nil {
        fmt.Println(err)
        return flag
        return flag,nil
    }
    flag = res.Success
    return flag
    return res.Success,res.Data
}

//查找所有算法
@@ -62,22 +60,38 @@
}

//通过id获取算法信息
func (api SdkApi) GetById(id string) protomsg.Sdk{
    var sdk protomsg.Sdk
func (api SdkApi) GetById(id string) (bool,interface{}){
    url := BASIC_URL + DATA_URL_PREFIX + "/sdk/getById"
    client := NewClient()
    paramMap := make(map[string]string)
    paramMap["id"] = id
    respBody, err := client.DoGetRequest(url, paramMap, nil)
    if err !=nil {
        return sdk
        return false,nil
    }
    var res Result
    if err = json.Unmarshal(respBody, &res); err != nil {
        fmt.Println(err)
        return sdk
        return false,nil
    }
    return res.Success,res.Data
}

func (api SdkApi) FindByTaskId(taskId string) (flag bool,sdks []protomsg.Sdk) {
    url := BASIC_URL + DATA_URL_PREFIX + "/sdk/findByTaskId"
    client := NewClient()
    paramMap := make(map[string]string)
    paramMap["taskId"] = taskId
    respBody, err := client.DoGetRequest(url, paramMap, nil)
    if err !=nil {
        return false,nil
    }
    var res Result
    if err = json.Unmarshal(respBody, &res); err != nil {
        fmt.Println(err)
        return false,nil
    }
    bytes, _ := json.Marshal(res.Data)
    err = json.Unmarshal(bytes, &sdk)
    return sdk
    err = json.Unmarshal(bytes, &sdks)
    return true,sdks
}

 taskApi.go

@@ -1,7 +1,7 @@
package dbapi

import (
    "basic.com/pubsub/protomsg.git"
    "analyweb/protomsg"
    "encoding/json"
    "fmt"
)
@@ -26,3 +26,82 @@
    err = json.Unmarshal(bytes, &taskInfos)
    return taskInfos
}

func (api TaskApi) Add(paramBody map[string]interface{}) (bool,interface{}) {
    url := BASIC_URL + DATA_URL_PREFIX + "/task/add"
    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 {
        fmt.Println(err)
        return false,nil
    }
    return res.Success,res.Data
}

func (api TaskApi) Delete(taskId string) (bool,interface{}){
    url := BASIC_URL + 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(taskId string,sdkId string) (bool,interface{}) {
    url := BASIC_URL + DATA_URL_PREFIX + "/task/addTaskSdk"
    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) UpdateTaskStatus(paramBody map[string]string) (bool,interface{}) {
    url := BASIC_URL + DATA_URL_PREFIX + "/task/addTaskSdk"
    client := NewClient()
    respBody, err := client.DoPostRequest(url, CONTENT_TYPE_FORM, nil,paramBody, 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 := BASIC_URL + 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
}