add add enable status control service

sunty

2019-08-01 26552269775de6ab02d85f9de93cb80e72b5ddea

add add enable status control service

 extend/esutil/EsClient.go

@@ -107,7 +107,7 @@
    }
    boundary := writer.Boundary()
    close_buf := bytes.NewBufferString(fmt.Sprintf("\r\n--%s--\r\n", boundary))
    fmt.Println("PostFormData.fileLen:",len(fileBytes))
    fmt.Println("PostFormData.fileLen:", len(fileBytes))
    file := bytes.NewBuffer(fileBytes)
    request_reader := io.MultiReader(body, file, close_buf)

@@ -245,31 +245,61 @@
        return dat
    }
}

//解析http
func EsReq(method string, url string, parama []byte) (buf []byte, err error) {
    timeout := time.Duration(10 * time.Second) 
    client := http.Client{
        Timeout: timeout,
    }
    request, err := http.NewRequest(method, url, bytes.NewBuffer(parama)) 
    request.Header.Set("Content-type", "application/json")
    timeout := time.Duration(10 * time.Second)
    client := http.Client{
        Timeout: timeout,
    }
    request, err := http.NewRequest(method, url, bytes.NewBuffer(parama))
    request.Header.Set("Content-type", "application/json")

    if err != nil {
        fmt.Println("build request fail !")
        return nil, err 
    }
    if err != nil {
        fmt.Println("build request fail !")
        return nil, err
    }

    resp, err := client.Do(request)
    if err != nil{
        fmt.Println("request error: ", err)
        return nil, err 
    }
    resp, err := client.Do(request)
    if err != nil {
        fmt.Println("request error: ", err)
        return nil, err
    }

    defer resp.Body.Close()
    body, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        fmt.Println(err) 
        return nil , err
    }
    return body, nil
}
    defer resp.Body.Close()
    body, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        fmt.Println(err)
        return nil, err
    }
    return body, nil
}

//解析json
func Sourcelist(buf []byte) (sources []map[string]interface{}, err error) {
    var info interface{}
    json.Unmarshal(buf, &info)
    out, ok := info.(map[string]interface{})
    if !ok {
        return nil, errors.New("http response interface can not change map[string]interface{}")
    }

    middle, ok := out["hits"].(map[string]interface{})
    if !ok {
        return nil, errors.New("first hits change error!")
    }
    for _, in := range middle["hits"].([]interface{}) {
        tmpbuf, ok := in.(map[string]interface{})
        if !ok {
            fmt.Println("change to source error!")
            continue
        }
        source, ok := tmpbuf["_source"].(map[string]interface{})
        if !ok {
            fmt.Println("change _source error!")
            continue
        }
        sources = append(sources, source)
    }
    return sources, nil
}

 main.go

@@ -4,33 +4,36 @@
    "basic.com/dbapi.git"
    "flag"
    "github.com/golang/glog"
    "github.com/robfig/cron"
    "strconv"
    "webserver/extend/config"
    "webserver/extend/logger"
    "webserver/router"
    "webserver/service"
)

var envirment = flag.String("e", "dev", "")
var dbIp = flag.String("dbIp","127.0.0.1","default dbIp=127.0.0.1")
var dbPort = flag.String("dbPort","8001","default dbPort=8001")
func init(){
var dbIp = flag.String("dbIp", "127.0.0.1", "default dbIp=127.0.0.1")
var dbPort = flag.String("dbPort", "8001", "default dbPort=8001")

func init() {
    var logFile = "./logger/webserver.log"
    var logSaveDays    =    15
    var logSaveDays = 15

    // 日志初始化
    logger.Config(logFile, logger.DebugLevel)
    logger.SetSaveDays(logSaveDays)
    logger.Info("loginit success !")
}
func main() {
    flag.Parse()
    service.InitService()

    p, err := strconv.Atoi(*dbPort)
    if err !=nil {
    if err != nil {
        p = 8001
    }
    dbapi.Init(*dbIp,p)
    //*dbIp = "192.168.1.123"
    //*dbIp = "192.168.1.182"
    dbapi.Init(*dbIp, p)

    flag.Usage = func() {
        glog.Exit("flag parse usage !")
@@ -39,8 +42,15 @@
    flag.Lookup("alsologtostderr").Value.Set("true")
    flag.Lookup("log_dir").Value.Set("./log")
    config.Init(*envirment)
}
func main() {
    c := cron.New()
    c.AddFunc("@ daily", func() {
        res := service.InitEnableStatus()
        logger.Debug(res)
    })
    c.Start()
    r := router.NewRouter()

    r.Run("0.0.0.0:8000")

    //defer new(gorun.SimpleFaceDetect).FaceDetactClose()

 service/EnableStatusControlService.go

New file
@@ -0,0 +1,150 @@
package service

import (
    "basic.com/dbapi.git"
    "encoding/json"
    "fmt"
    "strconv"
    "strings"
    "time"
    "webserver/extend/config"
    "webserver/extend/esutil"
    "webserver/extend/logger"
)

func GetVerificationData() []map[string]interface{} {
    url := "http://" + config.EsInfo.Masterip + ":" + config.EsInfo.Httpport +
        "/" + config.EsInfo.EsIndex.DbTables.IndexName + "/_search"
    var setApi dbapi.SysSetApi
    _, sysconf := setApi.GetServerInfo()
    jsonDsl := `{
    "query": {
        "bool": {
            "filter": [{
                    "term": {
                        "isDelete": "0"
                    }
                },
                {
                    "terms": {
                        "analyServerId": ["` + sysconf.ServerId + `",""]
                    }
                }
            ]
        }
    },
    "size": 10000
}
`
    buf, err := esutil.EsReq("POST", url, []byte(jsonDsl))
    if err != nil {
        logger.Debug(err)
    }

    sources, err := esutil.Sourcelist(buf)
    if err != nil {
        logger.Debug(err)
    }
    return sources
}

func VerificationTime(source []map[string]interface{}) map[string][]string {
    resultInfo := make(map[string][]string, 0)
    currentTime := time.Now()
    for _, v := range source {
        id := v["id"].(string)
        startTime := v["startTime"].(string)
        endTime := ""
        if v["endTime"] != nil {
            endTime = v["endTime"].(string)
        }
        st, _ := time.ParseInLocation("2006-01-02 15:04:05", startTime, time.Local)
        if endTime != "" {
            et, _ := time.ParseInLocation("2006-01-02 15:04:05", endTime, time.Local)
            if et.After(currentTime) && st.Before(currentTime) {
                resultInfo["effective"] = append(resultInfo["effective"], id)
            } else {
                resultInfo["invalid"] = append(resultInfo["invalid"], id)
            }
        } else if st.Before(currentTime) && endTime == "" {
            resultInfo["effective"] = append(resultInfo["effective"], id)
        } else {
            resultInfo["invalid"] = append(resultInfo["invalid"], id)
        }
    }
    //fmt.Println(resultInfo)
    return resultInfo
}

func UpdateEnableStatus(id []string, flag bool) (message string) {
    ids := strings.Replace(strings.Trim(fmt.Sprint(id), "[]"), " ", "\",\"", -1)
    status := 0
    if flag == true {
        status = 1
    }
    enable := strconv.Itoa(status)
    url := "http://" + config.EsInfo.Masterip + ":" + config.EsInfo.Httpport +
        "/" + config.EsInfo.EsIndex.DbTables.IndexName + "/_update_by_query?refresh"
    jsonDsl := `
            {
    "script": {
        "lang": "painless",
        "inline": "ctx._source.enable = ` + enable + `"
    },
    "query": {
        "terms": {
            "id": ["` + ids + `"]
        }
    }
}
`
    buf, err := esutil.EsReq("POST", url, []byte(jsonDsl))
    if err != nil {
        logger.Debug("http request info is err!")
        message = "修改失败"
    }
    var info interface{}
    json.Unmarshal(buf, &info)
    out, ok := info.(map[string]interface{})
    if !ok {
        logger.Debug("http response interface can not change map[string]interface{}")
        message = "修改失败"
    }
    middle, ok := out["updated"].(float64)
    if !ok {
        logger.Debug("first result change error!")
        message = "修改失败"
    }
    if middle > 0 {
        logger.Debug("修改成功")
        message = "修改成功"
    }
    return message
}

func InitEnableStatus() (messageInfo string) {
    verificationData := GetVerificationData()
    verificationTime := VerificationTime(verificationData)
    idOfEffective := verificationTime["effective"]
    idOfinvalid := verificationTime["invalid"]
    mesInfo := false
    effectiveMesInfo := ""
    invalidMesInfo := ""
    if len(idOfEffective) > 0 {
        effectiveMesInfo = UpdateEnableStatus(idOfEffective, true)
    } else {
        effectiveMesInfo = "修改成功"
    }
    if len(idOfinvalid) > 0 {
        invalidMesInfo = UpdateEnableStatus(idOfinvalid, false)
    } else {
        invalidMesInfo = "修改成功"
    }
    if effectiveMesInfo == "修改成功" && invalidMesInfo == "修改成功" {
        mesInfo = true
    }
    if mesInfo == true {
        messageInfo = "修改成功"
    }
    return messageInfo
}