迷宫网

1.action [router打到action请求]

package action

import (
    "encoding/json"
    "fmt"
    "log"
    "net/http"
    sDb "sms-keywords/data/db"
    sRedis "sms-keywords/data/redis"
    "sms-keywords/lib"
    sLog "sms-keywords/lib/log"
    search "sms-keywords/lib/words"
    . "sms-keywords/model"
    sTask "sms-keywords/task"
    "strings"
    "sync"
)

type Res struct {
    Res     bool   `json:"res"`
    Keyword string `json:"keyword"`
    Type    string `json:"type"`
}

type ResMap map[string]Res

type ResAll struct {
    Res            bool     `json:"res"`
    KeywordsReject []string `json:"keywords_reject"`
    KeywordsAudit  []string `json:"keywords_audit"`
}

/*
 * 关键词 Find One
 */
func KeywordsSearch(w http.ResponseWriter, r *http.Request) {
    defer r.Body.Close()
    defer func() {
        if err := recover(); err != nil {
            log.Printf("Action: [%s] , err[%s]", "KeywordsSearch", err)
            _, _ = w.Write([]byte(ErrorMsg(fmt.Sprintf("program error"))))
            return
        }
        return
    }()
    w.Header().Set("content-type", "text/json")

    content := r.FormValue("content")
    if content == "" {
        w.WriteHeader(400)
        _, _ = w.Write([]byte(ErrorMsg(fmt.Sprintf("param error：content"))))
        return
    }

    businessType := r.FormValue("business_type")
    if businessType == "" {
        w.WriteHeader(400)
        _, _ = w.Write([]byte(ErrorMsg(fmt.Sprintf("param error：business_type"))))
        return
    }
    checkId := r.FormValue("check_id")
    if checkId == "" {
        w.WriteHeader(400)
        _, _ = w.Write([]byte(ErrorMsg(fmt.Sprintf("param error：check_id"))))
        return
    }
    useCache := r.FormValue("use_cache")

    cacheKey := sRedis.GetCacheKey(content, checkId)
    checkKey := sRedis.GetCheckKey(businessType, checkId)
    obj := sTask.G_Obj.Map[checkKey]
    res := check(checkId, obj, content, cacheKey, useCache)
    sLog.SugarLogger.Infof("check content: [%s]", content)
    msg := SuccessMsg(res)
    _, _ = w.Write([]byte(msg))
}

/*
 * 关键词 Find One - 批量
 */
func KeywordsBatchSearch(w http.ResponseWriter, r *http.Request) {
    defer r.Body.Close()
    defer func() {
        if err := recover(); err != nil {
            log.Printf("Action: [%s] , err[%s]", "KeywordsBatchSearch", err)
            _, _ = w.Write([]byte(ErrorMsg(fmt.Sprintf("program error"))))
            return
        }
        return
    }()

    w.Header().Set("content-type", "text/json")

    content := r.FormValue("content")
    if content == "" {
        w.WriteHeader(400)
        _, _ = w.Write([]byte(ErrorMsg(fmt.Sprintf("param error：content"))))
        return
    }

    businessType := r.FormValue("business_type")
    if businessType == "" {
        w.WriteHeader(400)
        _, _ = w.Write([]byte(ErrorMsg(fmt.Sprintf("param error：business_type"))))
        return
    }
    checkIds := r.FormValue("check_ids")
    if checkIds == "" {
        w.WriteHeader(400)
        _, _ = w.Write([]byte(ErrorMsg(fmt.Sprintf("param error：check_ids"))))
        return
    }

    useCache := r.FormValue("use_cache")

    checkArr := strings.Split(checkIds, ",")
    arrLen := len(checkArr)
    ch := make(chan ResMap, arrLen)
    var wg sync.WaitGroup
    for _, checkId := range checkArr {
        wg.Add(1)
        go searchKeywordAsync(&wg, businessType, content, checkId, useCache, ch)
    }
    wg.Wait()
    close(ch)

    resMap := make(ResMap)
    for data := range ch {
        for k, v := range data {
            resMap[k] = v
        }
    }
    sLog.SugarLogger.Infof("check content: [%s], checkIds: [%s] ", content, checkIds)
    msg := SuccessMsg(resMap)
    _, _ = w.Write([]byte(msg))
}

// 协程处理
func searchKeywordAsync(wg *sync.WaitGroup, businessType, content, checkId, useCache string, ch chan ResMap) {
    defer wg.Done()
    defer func() {
        if err := recover(); err != nil {
            log.Printf("Action: [%s] , err[%s]", "searchKeywordAsync", err)
        }
        return
    }()

    resMap := make(ResMap)
    cacheKey := sRedis.GetCacheKey(content, checkId)
    checkKey := sRedis.GetCheckKey(businessType, checkId)
    obj := sTask.G_Obj.Map[checkKey]
    res := check(checkId, obj, content, cacheKey, useCache)

    if !res.Res && len(res.Keyword) == 0 {
        res.Res = true
    }
    resMap[checkId] = res
    ch <- resMap
}

// 校验内容
func check(checkId string, obj *sTask.SearchObj, content, cacheKey, useCache string) Res {
    defer func() {
        if err := recover(); err != nil {
            log.Printf("Action: [%s] , err[%s]", "check", err)
        }
        return
    }()

    rejectTypes := []string{"reject", "rejectGroup"}
    auditTypes := []string{"audit", "auditGroup"}

    // 拦截
    rejectRes := checkType(sDb.TYPE_REJECT, rejectTypes, obj, content, checkId)
    if !rejectRes.Res {
        return rejectRes
    }

    // 审核
    auditRes := checkType(sDb.TYPE_AUDIT, auditTypes, obj, content, checkId)
    if !auditRes.Res {
        return auditRes
    }

    res := new(Res)
    res.Res = true
    res.Keyword = ""
    res.Type = ""
    return *res
}

func checkType(checkType string, checkTypeList []string, obj *sTask.SearchObj, content string, checkId string) Res {
    res := new(Res)
    res.Res = true
    res.Keyword = ""
    res.Type = checkType
    var objCheck *search.StringSearchEx
    var objCheckGroup *search.StringSearchEx
    if checkType == sDb.TYPE_AUDIT {
        objCheck = obj.Audit
        objCheckGroup = obj.AuditGroup
    } else {
        objCheck = obj.Reject
        objCheckGroup = obj.RejectGroup
    }

    for _, t := range checkTypeList {
        if t == checkType {
            res := checkFirst(objCheck, content, checkType)
            if !res.Res {
                return *res
            }
        } else {
            // 组合关键词
            if objCheckGroup != nil {
                keywords := objCheckGroup.FindAll(content)
                sLog.SugarLogger.Debugf("%+v", keywords)
                if len(keywords) > 0 {
                    keywordsList := checkGroupKeywords(checkId, keywords, false)
                    if len(keywordsList) > 0 {
                        res.Res = false
                        res.Type = checkType
                        res.Keyword = keywordsList[0]
                        return *res
                    }
                }
            }
        }
    }
    return *res
}

func checkFirst(objCheck *search.StringSearchEx, content string, checkType string) *Res {
    res := new(Res)
    res.Res = true
    res.Keyword = ""
    res.Type = ""
    if objCheck != nil {
        keyword := objCheck.FindFirst(content)
        sLog.SugarLogger.Debugf("%+v", keyword)
        if keyword != "" {
            res.Res = false
            res.Keyword = keyword
            res.Type = checkType
            resJson, _ := json.Marshal(res)
            sLog.SugarLogger.Debugf("checkFirst arr: [%s]", resJson)
            return res
        }
    }
    return res
}

// 判断组合关键词是否命中
func checkGroupKeywords(checkId string, keywords []string, matchAll bool) []string {
    var keywordList []string
    groupKeywords := sRedis.GetKeywordsGroup(checkId, keywords)
    for _, groupList := range groupKeywords {
        for _, group := range groupList {
            tag := true
            groupArr := strings.Split(group, "&")
            for _, word := range groupArr {
                if !lib.InArray(word, keywords) {
                    tag = false
                    break
                }
            }
            //
            if tag {
                if !matchAll  {
                    keywordList = append(keywordList, group)
                    resJson, _ := json.Marshal(keywordList)
                    sLog.SugarLogger.Debugf("checkGroupKeywords arr: [%s]", resJson)
                    return keywordList
                } else {
                    keywordList = append(keywordList, group)
                }
            }
        }
    }
    resJson, _ := json.Marshal(keywordList)
    sLog.SugarLogger.Debugf("checkGroupKeywords arr: [%s]", resJson)
    return keywordList
}


// ------------------------
/*
 * 关键词 Find All
 */
func KeywordsMatchAll(w http.ResponseWriter, r *http.Request) {
    defer r.Body.Close()
    defer func() {
        if err := recover(); err != nil {
            log.Printf("Action: [%s] , err[%s]", "KeywordsMatchAll", err)
            _, _ = w.Write([]byte(ErrorMsg(fmt.Sprintf("program error"))))
            return
        }
        return
    }()
    w.Header().Set("content-type", "text/json")

    content := r.FormValue("content")
    businessType := r.FormValue("business_type")
    checkId := r.FormValue("check_id")
    useCache := r.FormValue("use_cache")

    if content == "" {
        w.WriteHeader(400)
        _, _ = w.Write([]byte(ErrorMsg(fmt.Sprintf("param error：content"))))
        return
    }
    if businessType == "" {
        w.WriteHeader(400)
        _, _ = w.Write([]byte(ErrorMsg(fmt.Sprintf("param error：business_type"))))
        return
    }
    if checkId == "" {
        w.WriteHeader(400)
        _, _ = w.Write([]byte(ErrorMsg(fmt.Sprintf("param error：check_id"))))
        return
    }

    cacheKey := sRedis.GetCacheKey(content, checkId)
    checkKey := sRedis.GetCheckKey(businessType, checkId)
    obj := sTask.G_Obj.Map[checkKey]
    res := checkAll(checkId, obj, content, cacheKey, useCache)
    sLog.SugarLogger.Infof("check content: [%s]", content)
    msg := SuccessMsg(res)
    _, _ = w.Write([]byte(msg))
}

// 全匹配
func checkAll(checkId string, obj *sTask.SearchObj, content, cacheKey, useCache string) ResAll {
    defer func() {
        if err := recover(); err != nil {
            log.Printf("Action: [%s] , err[%s]", "checkAll", err)
        }
        return
    }()
    types := []string{"reject", "audit"}
    groupTypes := []string{"rejectGroup", "auditGroup"}
    res := new(ResAll)
    res.Res = true
    res.KeywordsReject = []string{}
    res.KeywordsAudit = []string{}

    for _, t := range types {
        var objCheck *search.StringSearchEx
        if t == sDb.TYPE_REJECT {
            objCheck = obj.Reject
        } else {
            objCheck = obj.Audit
        }
        if objCheck != nil {
            keywords := objCheck.FindAll(content)
            sLog.SugarLogger.Debugf("%+v", keywords)
            if len(keywords) > 0 {
                res.Res = false
                if t == "reject" {
                    res.KeywordsReject = keywords
                } else {
                    res.KeywordsAudit = keywords
                }
            }
        }
    }

    for _, t := range groupTypes {
        var objCheck *search.StringSearchEx
        var  checkType string
        if t == sDb.TYPE_REJECT_GROUP {
            objCheck = obj.RejectGroup
            checkType = sDb.TYPE_REJECT
        } else {
            objCheck = obj.AuditGroup
            checkType = sDb.TYPE_AUDIT
        }
        if objCheck != nil {
            keywords := objCheck.FindAll(content)
            sLog.SugarLogger.Debugf("%+v", keywords)
            if len(keywords) > 0 {
                groupList := checkGroupKeywords(checkId, keywords, true)
                if len(groupList) > 0 {
                    res.Res = false
                    if checkType == sDb.TYPE_REJECT {
                        res.KeywordsReject = append(res.KeywordsReject, groupList...)
                    } else {
                        res.KeywordsAudit = append(res.KeywordsAudit, groupList...)
                    }
                }
            }
        }
    }

    resJson, _ := json.Marshal(res)
    sLog.SugarLogger.Debugf("res: [%s]", resJson)
    return *res
}

2.respone统一返回处理

package model

import (
    "encoding/json"
    sLog "sms-keywords/lib/log"
)

type ApiData struct {
    ErrCode int         `json:"err_code"`
    ErrMsg  string      `json:"err_msg"`
    Data    interface{} `json:"data"`
}

func SuccessMsg(data interface{}) string {
    res := new(ApiData)
    res.ErrCode = 0
    res.ErrMsg = "success"
    res.Data = data
    msg, _ := json.Marshal(res)
    sLog.SugarLogger.Infof("http response success: [%s]", msg)
    return string(msg)
}

func ErrorMsg(msg string) string {
    res := new(ApiData)
    res.ErrCode = 10001
    res.ErrMsg = msg
    res.Data = ""
    errMsg, _ := json.Marshal(res)
    sLog.SugarLogger.Infof("http response error: [%s]", errMsg)
    return string(errMsg)
}