datatag/src/service/rule_service.go

package service

import (
	"encoding/json"
	"fmt"
	"io"
	"io/ioutil"
	"net/http"
	"os"
	qu "qfw/util"
	"strconv"
	"strings"
	"time"
	. "util"

	"github.com/go-xweb/xweb"
	"gopkg.in/mgo.v2/bson"
)

type Rule struct {
	*xweb.Action
	//rule
	ruleList   xweb.Mapper `xweb:"/service/rule/list"`   //规则列表
	ruleCreate xweb.Mapper `xweb:"/service/rule/create"` //新建规则
	ruleDel    xweb.Mapper `xweb:"/service/rule/del"`    //删除规则
	ruleEdit   xweb.Mapper `xweb:"/service/rule/edit"`   //编辑规则
	ruleSave   xweb.Mapper `xweb:"/service/rule/save"`   //保存规则
	ruleImport xweb.Mapper `xweb:"/service/rule/import"` //导入文件excel
	//history
	archive xweb.Mapper `xweb:"/service/rule/archive"` //存档
	history xweb.Mapper `xweb:"/service/rule/history"` //变更列表

	productData  xweb.Mapper `xweb:"/service/rule/produce"`  //生成预览数据
	downloadData xweb.Mapper `xweb:"/service/rule/download"` //下载数据
	demoData     xweb.Mapper `xweb:"/service/rule/preview"`  //预览数据
	exportEs     xweb.Mapper `xweb:"/service/rule/exportes"` //导出es

}

//规则列表
func (r *Rule) RuleList() {
	defer qu.Catch()
	if r.Method() == "POST" {
		start, _ := r.GetInteger("start")
		limit, _ := r.GetInteger("length")
		draw, _ := r.GetInteger("draw")
		searchStr := r.GetString("search[value]")
		search := strings.TrimSpace(searchStr)
		//qu.Debug(start, limit, draw, search)
		query := bson.M{
			"b_delete": false,
		}
		if search != "" {
			query["$or"] = []interface{}{
				bson.M{"s_customername": bson.M{"$regex": search}},
				bson.M{"s_tagname": bson.M{"$regex": search}},
			}
		}

		data, _ := Mgo.Find("tags", query, nil, nil, false, start, limit)
		count := Mgo.Count("tags", query)
		r.ServeJson(map[string]interface{}{
			"draw":            draw,
			"data":            data,
			"recordsFiltered": count,
			"recordsTotal":    count,
		})
	} else {
		r.T["preview_href"] = PreviewHref
		r.Render("private/rule_list.html", &r.T)
	}
}

func (r *Rule) RuleCreate() {
	defer qu.Catch()
	if r.Method() == "POST" {

	} else {
		r.T["province"] = Province
		r.T["city"] = ProvinceCitys
		r.T["district"] = CityDistricts
		r.T["topTypeArr"] = TopTypeArr
		r.T["subTypeArr"] = SubTypeArr
		r.T["matchTypeMap"] = MatchTypeMap
		r.T["existField"] = ExistFiled
		r.T["buyerClass"] = BuyerClass
		r.T["scopeClass"] = ScopeClassMap
		r.Render("private/rule_create.html", &r.T)
	}
}

func (r *Rule) RuleDel() {
	defer qu.Catch()
	_id := r.GetString("_id")
	set := bson.M{
		"$set": bson.M{
			"b_delete": true,
		},
	}
	b := Mgo.UpdateById("tags", _id, set)
	fmt.Println("Delete Tags Data Id：", _id, b)
	r.ServeJson(map[string]interface{}{
		"rep": b,
	})
}

func (r *Rule) RuleImport() {
	defer qu.Catch()
	if r.Method() == "POST" {
		mf, _, err := r.GetFile("xlsx")
		if err == nil {
			binary, err := ioutil.ReadAll(mf)
			if err == nil {
				rdata, err := Parsxlsx(binary)
				if err == nil {
					//id, rep := updateDbXf("", rdata)
					//qu.Debug("import data:", rdata)
					r.ServeJson(map[string]interface{}{
						"rdata": rdata,
						"id":    "",
						"rep":   true,
					})
					return
				}
			}
		}
		r.ServeJson(map[string]interface{}{
			"rep": false,
		})
	}
}

func (r *Rule) RuleEdit() {
	defer qu.Catch()
	id := r.GetString("id")         //规则列表编辑
	dataid := r.GetString("dataid") //反馈列表编辑
	query := bson.M{}
	if id != "" {
		query["_id"] = qu.StringTOBsonId(id)
	} else if dataid != "" {
		query["s_dataid"] = dataid
	}
	data, _ := Mgo.FindOneByField("tags", query, `{}`)
	(*data)["id"] = qu.BsonIdToSId((*data)["_id"])
	r.T["data"] = *data
	r.T["province"] = Province
	r.T["city"] = ProvinceCitys
	r.T["district"] = CityDistricts
	r.T["topTypeArr"] = TopTypeArr
	r.T["subTypeArr"] = SubTypeArr
	r.T["matchTypeMap"] = MatchTypeMap
	r.T["existField"] = ExistFiled
	r.T["buyerClass"] = BuyerClass
	r.T["scopeClass"] = ScopeClassMap
	r.Render("private/rule_edit.html", &r.T)
}

func (r *Rule) RuleSave() {
	defer qu.Catch()
	if r.Method() == "POST" {
		user := r.GetSession("user").(map[string]interface{})
		data := GetPostForm(r.Request)
		id := data["id"].(string)
		delete(data, "id")
		o_rules := []map[string]interface{}{}
		o_rulesStr := data["o_rules"].(string)
		json.Unmarshal([]byte(o_rulesStr), &o_rules)
		data["o_rules"] = o_rules
		data["i_esquerytype"] = 2                                        //手动输入es
		if s_esquery, _ := data["s_esquery"].(string); s_esquery == "" { //自动生成es
			data["s_esquery"] = Utiltags(data)
			data["i_esquerytype"] = 1
		}
		i_createtime := time.Now().Unix()
		data["i_createtime"] = i_createtime
		data["i_updatetime"] = i_createtime
		data["s_createuser"] = user["name"]
		data["s_updateuser"] = user["name"]
		data["b_delete"] = false
		s_customername := data["s_customername"].(string)
		s_tagname := data["s_tagname"].(string)
		data["s_dataid"] = qu.SE.EncodeString(fmt.Sprintf("%v", i_createtime) + s_customername + s_tagname)
		id, rep := updateDbXf(id, data) //保存tags
		r.ServeJson(map[string]interface{}{
			"id":       id,
			"rep":      rep,
			"s_dataid": data["s_dataid"],
		})
	}
}

func (r *Rule) Archive() {
	defer qu.Catch()
	if r.Method() == "POST" {
		rep := false
		_id := r.GetString("_id")
		query := bson.M{
			"_id": qu.StringTOBsonId(_id),
		}
		tag, _ := Mgo.FindOne("tags", query)
		if len(*tag) > 0 {
			user := r.GetSession("user").(map[string]interface{})
			histoty, _ := Mgo.FindOne("tags_history", `{"s_tagid":"`+_id+`"}`)
			s_state := "创建"
			if len(*histoty) > 0 { //该id已有记录
				s_state = "变更"
			}
			(*tag)["s_tagid"] = _id                    //tags表id
			(*tag)["s_state"] = s_state                //状态
			(*tag)["l_changetime"] = time.Now().Unix() //变更时间
			(*tag)["s_changeperson"] = user["name"]
			id := Mgo.Save("tags_history", tag)
			if id != "" {
				rep = true
			}
		}
		r.ServeJson(map[string]interface{}{
			"rep": rep,
		})
	}
}

func (r *Rule) History() {
	defer qu.Catch()
	tagid := r.GetString("tagid")
	if r.Method() == "POST" {
		data, _ := Mgo.Find("tags_history", `{"s_tagid":"`+tagid+`"}`, nil, nil, false, -1, -1)
		r.ServeJson(map[string]interface{}{
			"data": data,
		})
	} else {
		r.T["tagid"] = tagid
		r.Render("private/rule_history.html", &r.T)
	}
}

func (r *Rule) ExportEs() {
	defer qu.Catch()
	id := r.GetString("id")
	if id == "" {
		return
	}
	w := r.ResponseWriter
	tag, _ := Mgo.FindById("tags", id, `{}`)
	s_esquery := (*tag)["s_esquery"].(string)
	createEsJosn(s_esquery)
	file, err := os.Open("./download/es.json")
	defer file.Close()
	if err != nil {
		fmt.Println("Open File Err:", err)
		r.ServeJson(map[string]interface{}{
			"rep": false,
		})
		return
	}
	fileHeader := make([]byte, 512)
	file.Read(fileHeader)
	fileStat, _ := file.Stat()
	w.Header().Set("Content-Disposition", "attachment; filename=./download/es.json")
	w.Header().Set("Content-Type", http.DetectContentType(fileHeader))
	w.Header().Set("Content-Length", strconv.FormatInt(fileStat.Size(), 10))
	file.Seek(0, 0)
	io.Copy(w, file)
	return
}

func createEsJosn(es string) {
	defer qu.Catch()
	jmap := make(map[string]interface{})
	err := json.Unmarshal([]byte(es), &jmap)
	//j, err := json.Marshal(es)
	if err != nil {
		fmt.Println("S_esquery To Json Err:", err)
		return
	}
	fp, err := os.OpenFile("./download/es.json", os.O_RDWR|os.O_CREATE, 0755)
	if err != nil {
		fmt.Println("Create File Err:", err)
		return
	}
	defer fp.Close()
	j, _ := json.Marshal(jmap)
	_, err = fp.Write(j)
	if err != nil {
		fmt.Println("Write File Err:", err)
		return
	}
}

//更新xlsx db
func updateDbXf(id string, rdata map[string]interface{}) (rid string, rep bool) {
	defer qu.Catch()
	if id == "" {
		rid = Mgo.Save("tags", rdata)
		if rid != "" {
			rep = true
		} else {
			rep = false
		}
	} else {
		rid = id
		query := bson.M{
			"_id": qu.StringTOBsonId(id),
		}
		rep = Mgo.Update("tags", query, bson.M{"$set": rdata}, false, false)
	}
	return
}

func (r *Rule) DemoData() {
	defer qu.Catch()
	if r.Method() == "POST" {
		sDataid := r.GetString("s_dataid")
		start, _ := r.GetInteger("start")
		limit, _ := r.GetInteger("length")
		draw, _ := r.GetInteger("draw")
		query := bson.M{
			"s_dataid": sDataid,
		}
		data, _ := Mgo.Find("tagsdata", query, `{"publishtime":-1}`, nil, false, start, limit)
		count := Mgo.Count("tagsdata", query)
		r.ServeJson(map[string]interface{}{
			"data":            data,
			"draw":            draw,
			"recordsFiltered": count,
			"recordsTotal":    count,
		})
	}
}
func (r *Rule) ProductData() {
	defer qu.Catch()
	if r.Method() == "POST" {
		rep := false
		id := r.GetString("id")
		fmt.Println(id)
		tag, _ := Mgo.FindById("tags", id, `{}`)
		err := UtilEsFind(*tag)
		if err == nil {
			rep = true
		}
		r.ServeJson(map[string]interface{}{
			"rep": rep,
		})
	}
}
func (r *Rule) DownloadData() {
	defer qu.Catch()

	dataId := r.GetString("s_dataid")
	if path := ResponseXlsx(dataId); path == "" {
		r.ServeJson("内部错误")
	} else {
		r.ServeFile(path)
	}
}