labsop_mcs/backend/src/dashoo.cn/mcs_api_weixin/controllers/common.go

package controllers

import (
	"bytes"
	"encoding/json"
	"fmt"
	"io"
	"io/ioutil"
	"math/rand"
	"net/http"
	"os"
	"strconv"
	"strings"
	"time"

	"github.com/axgle/mahonia"
	"github.com/nsqio/go-nsq"

	"dashoo.cn/base_common/business/permission"
	"dashoo.cn/base_common/labsop"
	"dashoo.cn/base_common/utils"
)

var (
	Nsqdtcpaddr   string
	Nsqtopic      string
	SalesAdmin    string = "SalesAdmin" //分销商管理员
	ProjectSourse string = "coldchain"
)

type blackboxddata struct {
	Code      string
	Datapoint labsop.DatapointLabSop
}

// 保留两位小数
func Get2point(v float64) string {
	return strconv.FormatFloat(v, 'f', 2, 64)
}

//格式化时间
func FormatTime(timein time.Time) string {
	var timestring = timein.Format("2006-01-02")
	if strings.Contains("0001-01-01", timestring) {
		return ""
	} else {
		return timein.Format("2006-01-02")
	}

}

func Timeisnull(t time.Time) bool {
	var to time.Time
	return t.Equal(to)
}

func Apiget(str string) (body []byte) {
	str = strings.Replace(str, " ", "%20", -1)
	response, _ := http.Get(str)
	if response != nil {
		defer response.Body.Close()
		body, _ = ioutil.ReadAll(response.Body)
	}
	//json.Unmarshal(body, &devices)
	return
}

func Apipost(strUrl, method string, postDict interface{}) (body []byte) {
	strUrl = strings.Replace(strUrl, " ", "%20", -1)
	httpClient := &http.Client{
		//Transport:nil,
		//CheckRedirect: nil,
	}

	var httpReq *http.Request

	b, _ := json.Marshal(postDict)
	postBytesReader := bytes.NewReader(b)
	httpReq, _ = http.NewRequest(method, strUrl, postBytesReader)
	httpReq.Header.Add("Content-Type", "application/json")
	response, _ := httpClient.Do(httpReq)
	body, _ = ioutil.ReadAll(response.Body)
	return
}

func SaveDirectory(path string) {
	os.MkdirAll(path, os.ModePerm)
}

// 上传图片
func UploadImage(typename, path string, r *http.Request) string {
	fn, _, _ := r.FormFile("file")
	defer fn.Close()

	var spit string
	if os.IsPathSeparator('\\') { //前边的判断是否是系统的分隔符
		spit = "\\"
	} else {
		spit = "/"
	}
	var urlpath = path
	path = strings.Replace(path, "/", spit, -1)
	dir, _ := os.Getwd() //当前目录
	path = dir + path + spit + utils.ToStr(time.Now().Year()) + spit + fmt.Sprintf("%s", time.Now().Format("1")) + spit
	os.MkdirAll(path, os.ModePerm)

	var name = utils.GetGuid() + "." + typename
	f, _ := os.Create(path + name)

	defer f.Close()

	io.Copy(f, fn)
	return urlpath + utils.ToStr(time.Now().Year()) + "/" + fmt.Sprintf("%s", time.Now().Format("1")) + "/" + name
}

func GetTriggerItemNameByItem(item int) (name string) {
	switch item {
	case 1:
		name = ">"
	case 2:
		name = ">="
	case 3:
		name = "<"
	case 4:
		name = "<="
	case 5:
		name = "="
	}
	return
}

func GetChannelLast(code string) (lastdata labsop.DatapointLabSop, err error) {
	return labsop.GetBoxLastdata(strings.Replace(code, "c", "", 1))
}

func GetChannelCacheLast(code string) (lastdata labsop.BoxCache, err error) {
	return labsop.GetBox(strings.Replace(code, "c", "", 1))
}

func WriteAlertBindValue(code, value string) (err error) {
	key := strings.Replace(code, "c", "", 1)
	data := labsop.DatapointLabSop{Time: time.Now(), RequestData: value}
	err = labsop.UpdateBoxLastdata(key, data)
	if err == nil {
		cfg := nsq.NewConfig()
		Producernsq, _ := nsq.NewProducer(Nsqdtcpaddr, cfg)
		bdata, err := json.Marshal(blackboxddata{key, data})
		if err == nil {
			err = Producernsq.Publish(Nsqtopic, bdata)
		}
	}
	return
}

func GetChannelInfov2(code string, startandend ...int64) (cols []string, arrs [][]interface{}) {
	client := labsop.GetLabSopClient("coldcloud", "cc@1qaz2wsx", "coldcloud", "114.215.27.56:9086")
	sql := fmt.Sprintf("select * from %v ", code)
	if len(startandend) == 2 {
		sql = sql + fmt.Sprintf(" where time>%vs and time<%vs ", startandend[0], startandend[1])
	} else {
		sql = sql + " order by time desc limit 1"
	}
	data, err := client.QueryOneResultByCommand(sql)
	if err == nil && len(data) > 0 && len(data[0].Values) > 0 {
		cols, arrs = data[0].Columns, data[0].Values
	}
	return

}

func GetChannelBysql(sql string) (cols []string, arrs [][]interface{}) {
	client := labsop.GetLabSopClient("coldcloud", "cc@1qaz2wsx", "coldcloud", "47.92.249.239:9086")
	data, err := client.QueryOneResultByCommand(sql)
	if err == nil && len(data) > 0 && len(data[0].Values) > 0 {
		cols, arrs = data[0].Columns, data[0].Values

	}
	return

}

func CodertoGBK(str string) string {
	dec := mahonia.NewDecoder("UTF-8")
	enc := mahonia.NewEncoder("GBK")
	return enc.ConvertString(dec.ConvertString(str))
}

func CoderGBKtoUTF8(str string) string {
	dec := mahonia.FallbackDecoder(mahonia.NewDecoder("GBK"), mahonia.NewDecoder("UTF-8"))
	return dec.ConvertString(str)
}

//设备类型汇总
const (
	Device_Box              = "0"                            //设备，普通box
	Device_Alertor          = "4"                            //设备，报警器
	ChannelItem_Sensor      = "0,6,7,9,10,13,14,17,26,25,31" //sensor，常温，深低温，o2，co2，特殊（隐藏湿度的常温）,功率
	ChannelItem_Report      = "0,6,7,9,10,14"                //sensor报表使用，不需要功率，常温，深低温，o2，co2，特殊（隐藏湿度的常温）
	ChannelItem_Box         = "1"                            //sensor，box自身数据
	ChannelItem_TAndH       = "0"                            //sensor，常温，显示温湿度
	ChannelItem_Temperature = "6,10"                         //sensor，深低温，特殊，显示温度
	ChannelItem_Co2         = "9,26"                         //sensor，co2，显示温湿度，co2
	ChannelItem_O2          = "7,17"                         //sensor，o2，显示温湿度，O2
	ChannelItem_Power       = "13"                           //sensor，功率插座，显示功率，电量
	ChannelItem_HaveT       = "0,6,7,9,10"                   //含温度数据
	ChannelItem_HaveV       = "0,6,7,9,10"                   //含电压数据
	ChannelItem_HaveH       = "0,7,9"                        //含湿度数据
	ChannelItem_HaveCO2     = "9,26"                         //含二氧化碳数据，co2
	ChannelItem_HaveO2      = "7,17"                         //含氧气数据，o2
	Alertor_Alarm           = "2,4,5,8,12"                   //报警器，普通，纯报警，纯正常，android,条屏
	Alertor_AlarmBindData   = "3"                            //报警器，绑定数据
	Alertor_Alarm1          = "2"                            //报警器，普通
	Alertor_Alarm3          = "4"                            //报警器，纯报警
	Alertor_AlarmOnlyData   = "5"                            //报警器，纯正常
	Alertor_AlarmAndroid    = "8"                            //报警器，android
	Alertor_AlarmBaoJing    = "2,4,5,8"                      //报警器，报警
	Alertor_AlarmLed        = "12"                           //报警器，条屏
	Alertor_NeedAction      = "2,4,5,8"                      //报警器，需要添加动作
	Alertor_NotNeedAction   = "12"                           //报警器，不需要添加动作
)

//设备类型判断
func DeviceItemContain(itemenum, item string) bool {
	return utils.SliceContains(strings.Split(itemenum, ","), item)
}
func DeviceItemContainint(itemenum string, item int) bool {
	return utils.SliceContains(strings.Split(itemenum, ","), utils.ToStr(item))
}

func StringIsContain(strs string, str ...interface{}) bool {
	if len(str) == 1 {
		return utils.SliceContains(strings.Split(strs, ","), utils.ToStr(str[0]))
	} else if len(str) == 2 {
		return utils.SliceContains(strings.Split(strs, ","), utils.ToStr(str[0])) || utils.SliceContains(strings.Split(strs, ","), utils.ToStr(str[1]))
	}
	return false
}

func IsAuthorized(uid string, permissionItemCode string) bool {
	svc := permission.GetPermissionService(utils.DBE)
	return svc.IsAuthorized(uid, permissionItemCode)
}

func randInt(min int, max int) int {
	if max-min <= 0 {
		return min
	}
	rand.Seed(time.Now().UTC().UnixNano())
	return min + rand.Intn(max-min)
}

//比较大小
func Compare(item int, v1, v2 float64) bool {
	istrue := false
	switch item {
	case 1:
		istrue = v1 > v2
	case 2:
		istrue = v1 >= v2
	case 3:
		istrue = v1 < v2
	case 4:
		istrue = v1 <= v2
	case 5:
		istrue = v1 == v2
	}
	return istrue
}