scd_tools_go/service/tools/tool.go

package tools

import (
	"archive/zip"
	"bufio"
	"bytes"
	"encoding/base64"
	"encoding/binary"
	"errors"
	"fmt"
	"io"
	"io/fs"
	"io/ioutil"
	"log"
	"net"
	"net/http"
	"net/url"
	"os"
	"os/exec"
	"path"
	"path/filepath"
	"regexp"
	"runtime"
	"scd_check_tools/conf"
	"scd_check_tools/logger"
	"strconv"
	"strings"
	"sync"
	"time"
	"unicode"

	"golang.org/x/text/transform"

	"hash/crc32"

	"github.com/astaxie/beego/orm"

	"golang.org/x/text/encoding/simplifiedchinese"
	//"golang.org/x/text/transform"
)

var GlobalID int64

var MbTable = []uint16{0x0000, 0xC0C1, 0xC181, 0x0140, 0xC301, 0x03C0, 0x0280, 0xC241, 0xC601, 0x06C0, 0x0780, 0xC741, 0x0500, 0xC5C1, 0xC481, 0x0440, 0xCC01, 0x0CC0, 0x0D80, 0xCD41, 0x0F00, 0xCFC1, 0xCE81, 0x0E40, 0x0A00, 0xCAC1, 0xCB81, 0x0B40, 0xC901, 0x09C0, 0x0880, 0xC841, 0xD801, 0x18C0, 0x1980, 0xD941, 0x1B00, 0xDBC1, 0xDA81, 0x1A40, 0x1E00, 0xDEC1, 0xDF81, 0x1F40, 0xDD01, 0x1DC0, 0x1C80, 0xDC41, 0x1400, 0xD4C1, 0xD581, 0x1540, 0xD701, 0x17C0, 0x1680, 0xD641, 0xD201, 0x12C0, 0x1380, 0xD341, 0x1100, 0xD1C1, 0xD081, 0x1040, 0xF001, 0x30C0, 0x3180, 0xF141, 0x3300, 0xF3C1, 0xF281, 0x3240, 0x3600, 0xF6C1, 0xF781, 0x3740, 0xF501, 0x35C0, 0x3480, 0xF441, 0x3C00, 0xFCC1, 0xFD81, 0x3D40, 0xFF01, 0x3FC0, 0x3E80, 0xFE41, 0xFA01, 0x3AC0, 0x3B80, 0xFB41, 0x3900, 0xF9C1, 0xF881, 0x3840, 0x2800, 0xE8C1, 0xE981, 0x2940, 0xEB01, 0x2BC0, 0x2A80, 0xEA41, 0xEE01, 0x2EC0, 0x2F80, 0xEF41, 0x2D00, 0xEDC1, 0xEC81, 0x2C40, 0xE401, 0x24C0, 0x2580, 0xE541, 0x2700, 0xE7C1, 0xE681, 0x2640, 0x2200, 0xE2C1, 0xE381, 0x2340, 0xE101, 0x21C0, 0x2080, 0xE041, 0xA001, 0x60C0, 0x6180, 0xA141, 0x6300, 0xA3C1, 0xA281, 0x6240, 0x6600, 0xA6C1, 0xA781, 0x6740, 0xA501, 0x65C0, 0x6480, 0xA441, 0x6C00, 0xACC1, 0xAD81, 0x6D40, 0xAF01, 0x6FC0, 0x6E80, 0xAE41, 0xAA01, 0x6AC0, 0x6B80, 0xAB41, 0x6900, 0xA9C1, 0xA881, 0x6840, 0x7800, 0xB8C1, 0xB981, 0x7940, 0xBB01, 0x7BC0, 0x7A80, 0xBA41, 0xBE01, 0x7EC0, 0x7F80, 0xBF41, 0x7D00, 0xBDC1, 0xBC81, 0x7C40, 0xB401, 0x74C0, 0x7580, 0xB541, 0x7700, 0xB7C1, 0xB681, 0x7640, 0x7200, 0xB2C1, 0xB381, 0x7340, 0xB101, 0x71C0, 0x7080, 0xB041, 0x5000, 0x90C1, 0x9181, 0x5140, 0x9301, 0x53C0, 0x5280, 0x9241, 0x9601, 0x56C0, 0x5780, 0x9741, 0x5500, 0x95C1, 0x9481, 0x5440, 0x9C01, 0x5CC0, 0x5D80, 0x9D41, 0x5F00, 0x9FC1, 0x9E81, 0x5E40, 0x5A00, 0x9AC1, 0x9B81, 0x5B40, 0x9901, 0x59C0, 0x5880, 0x9841, 0x8801, 0x48C0, 0x4980, 0x8941, 0x4B00, 0x8BC1, 0x8A81, 0x4A40, 0x4E00, 0x8EC1, 0x8F81, 0x4F40, 0x8D01, 0x4DC0, 0x4C80, 0x8C41, 0x4400, 0x84C1, 0x8581, 0x4540, 0x8701, 0x47C0, 0x4680, 0x8641, 0x8201, 0x42C0, 0x4380, 0x8341, 0x4100, 0x81C1, 0x8081, 0x4040}

func NowTime() string {
	//大坑一个：必须使用这个时间格式化，忘记YYYY mm ss hh mi ss这些吧
	return time.Now().Format("2006-01-02 15:04:05")
}

func TimeSeq(bit ...int) int {
	if bit != nil && bit[0] == 13 {
		return int(time.Now().UnixNano() / 1e6)
	}
	return int(time.Now().Unix())
}

func Typeof(v interface{}) string {
	return fmt.Sprintf("%T", v)
}

//过滤特殊字符
//chars:过滤指定的字符，多个字符使用逗号分隔
func FilterSpecialChar(p string, chars ...string) string {
	if p == "" {
		return ""
	}
	v := "<|>|'"
	if len(chars) > 0 {
		v = strings.ReplaceAll(chars[0], ",", "|")
	}
	return regexp.MustCompile(v).ReplaceAllString(p, "")
}
func IsEmpty(p interface{}, defaultvalue ...string) string {
	if p == nil {
		if defaultvalue != nil && len(defaultvalue) > 0 {
			return defaultvalue[0]
		}
		return ""
	}
	objtype := Typeof(p)
	if objtype == "int" {
		return strconv.Itoa(p.(int))
	} else if objtype == "int32" {
		return strconv.FormatInt(int64(p.(int32)), 10)
	} else if objtype == "int64" {
		return strconv.FormatInt(p.(int64), 10)
	} else if objtype == "float64" {
		return strconv.FormatFloat(p.(float64), 'f', -1, 64)
	}
	v := p.(string)
	if v == "" {
		if defaultvalue != nil && len(defaultvalue) > 0 {
			return defaultvalue[0]
		}
	}
	return strings.Trim(v, " ")
}

func CheckErr(err error) {
	if err != nil {
		log.Println(err.Error())
	}
}

//多表达式分组匹配
//多个表达式组时使用&分隔,每个分组表达式可使用()括起来，更加易读，且内部内容必须符合正则表过式规则
//表达式样例1：(断路器)&(跳|合|闸){1,}&(位置)
//表达式样例2：Ia1&A&保护
func RexGroupTestMatch(regstr, soruce string) bool {
	if regstr == "" || soruce == "" {
		return false
	}
	regstrs := strings.Split(regstr, "&")
	if len(regstrs) > 1 {
		//未分组时，直接匹配
		fcdarex, err2 := regexp.Compile(regstr)
		if err2 != nil {
			logger.Logger.Error(err2, regstr)
			return false
		}
		return fcdarex.MatchString(soruce)
	}
	wg := sync.WaitGroup{}
	wg.Add(len(regstrs))
	wgResultFalse := map[string]bool{}
	for _, item := range regstrs {
		go func(item string) {
			fcdarex, err2 := regexp.Compile(item)
			if err2 != nil {
				logger.Logger.Error(err2, item)
				wgResultFalse["false"] = false
			} else if !fcdarex.MatchString(soruce) {
				wgResultFalse["false"] = false
			}
			wg.Done()
		}(item)
	}
	wg.Wait()
	matchSuccess := true
	if _, h := wgResultFalse["false"]; h {
		matchSuccess = false
	}
	return matchSuccess
}

//生成全局唯一ID序列
func GetSeqID() int64 {
	if GlobalID == 0 {
		GlobalID = 1
	} else {
		GlobalID = GlobalID + 1
	}
	return GlobalID
}

//不建议使用。建议直接使用log包
func Log(logdata interface{}) {
	if conf.GlobalConfig["loglevel"] == "4" || conf.GlobalConfig["loglevel"] == "5" {
		log.Println(logdata)
	}

}

//不建议使用。建议直接使用log包
func Error(logdata interface{}) {
	log.Println(logdata)
}

func FormatFileSize(size int64) string {
	if size == 0 {
		return "0B"
	} else if size < 1024 {
		return fmt.Sprintf("%dB", size)
	} else if size < (1024 * 1024) {
		return fmt.Sprintf("%.2fKB", float64(size)/float64(1024))
	} else if size < (1024 * 1024 * 1024) {
		return fmt.Sprintf("%.2fMB", float64(size)/float64(1024*1024))
	} else if size < (1024 * 1024 * 1024 * 1024) {
		return fmt.Sprintf("%.2fGB", float64(size)/float64(1024*1024*1024))
	} else if size < (1024 * 1024 * 1024 * 1024 * 1024) {
		return fmt.Sprintf("%.2fTB", float64(size)/float64(1024*1024*1024*1024))
	} else {
		return ""
	}

}

func CalCheckCRC32(data string) string {
	return fmt.Sprintf("%X", crc32.ChecksumIEEE([]byte(data)))
}

func CalCheckXor(command16 string) string {
	var a int64 = 0
	for i := 0; i < len(command16); i++ {
		a1, _ := strconv.ParseInt(command16[i:i+2], 16, 16)
		a2, _ := strconv.ParseInt(command16[i+2:i+4], 16, 16)
		a = a ^ (a1 ^ a2)
		i = i + 3
	}
	h := fmt.Sprintf("%X", a)
	return h
}

func CalCheckCrc16_Modbus(data []byte) string {
	var crc16 uint16
	crc16 = 0xffff
	for _, v := range data {
		n := uint8(uint16(v) ^ crc16)
		crc16 >>= 8
		crc16 ^= MbTable[n]
	}
	int16buf := new(bytes.Buffer)
	binary.Write(int16buf, binary.LittleEndian, crc16)
	r := fmt.Sprintf("%+X", int16buf.Bytes())
	return r
}

func CalCheckCRC(commd string) (r string) {
	var i = 0
	var sum = 0
	for {
		h1 := commd[i : i+2]
		n, _ := strconv.ParseUint(h1, 16, 32)
		//fmt.Println(h1 + "=====" + strconv.Itoa(int(n)))
		sum = sum + int(n)
		i = i + 2
		if i >= len(commd) {
			break
		}
	}
	if sum > 256 {
		sum = sum - 256
	}
	var hexStr = strconv.FormatInt(int64(sum), 16)
	return hexStr
}

func GetNetPicBase64(picurl string) string {
	resp, err := http.Get(picurl)

	if err != nil {
		fmt.Println(err)
		return ""
	}
	defer resp.Body.Close()
	/*body, er := ioutil.ReadAll(resp.Body)
	if er != nil {
		fmt.Println(er)
		return ""
	}*/
	dir, _ := filepath.Abs(filepath.Dir(os.Args[0]))
	reader := bufio.NewReaderSize(resp.Body, 500*1024)
	fileName := path.Base(picurl)
	file, _ := os.Create(dir + "/tests/" + fileName)
	writer := bufio.NewWriter(file)
	io.Copy(writer, reader)
	defer file.Close()
	ff, _ := os.Open(dir + "/tests/" + fileName)
	defer ff.Close()
	sourcebuffer := make([]byte, 500*1024)
	n, _ := ff.Read(sourcebuffer)
	//base64压缩
	sourcestring := base64.StdEncoding.EncodeToString(sourcebuffer[:n])
	return sourcestring
}
func GetPicBase64(picpath string, saveas string) string {
	ff, _ := os.Open(picpath)
	defer ff.Close()
	sourcebuffer := make([]byte, 5*1024*1024)
	n, _ := ff.Read(sourcebuffer)
	//base64压缩
	sourcestring := base64.StdEncoding.EncodeToString(sourcebuffer[:n])
	if saveas != "" {
		os.WriteFile(saveas, []byte(sourcestring), fs.ModePerm)

	}
	return sourcestring
}
func Base64MakePic(base64str string, picPath string) error {
	//fmt.Println(base64str)
	ddd, _ := base64.StdEncoding.DecodeString(base64str[len("data:image/jpeg;base64,"):])
	return ioutil.WriteFile(picPath, ddd, 0666)
}

//解析datatable参数为Map对象
func ParseDatatableParamByFormdata(reqStr url.Values) map[string]interface{} {
	var result = map[string]interface{}{"datatable": map[string]interface{}{}}
	datatable := map[string]interface{}{"sort": map[string]interface{}{"sort": reqStr.Get("datatable[sort][sort]"), "field": reqStr.Get("datatable[sort][field]")}, "pagination": map[string]interface{}{"page": reqStr.Get("datatable[pagination][page]"), "perpage": reqStr.Get("datatable[pagination][perpage]")}}
	for k, v := range reqStr {
		if strings.HasPrefix(k, "datatable") {
			if !strings.HasPrefix(k, "datatable[pagination]") && !strings.HasPrefix(k, "datatable[sort]") {
				newKey := strings.Replace(k, "datatable", "", 1)
				newKey = strings.Replace(newKey, "[", "", 1)
				newKey = strings.Replace(newKey, "]", "", 1)
				datatable[newKey], _ = url.QueryUnescape(v[0])
			}
		} else {
			datatable[k], _ = url.QueryUnescape(v[0])
		}
	}
	result["datatable"] = datatable
	return result
}

//解析datatable参数为Map对象
func ParseFormParam(reqStr url.Values) map[string]interface{} {
	var result = map[string]interface{}{"datatable": map[string]interface{}{}}
	datatable := map[string]interface{}{"sort": map[string]interface{}{"sort": reqStr.Get("datatable[sort][sort]"), "field": reqStr.Get("datatable[sort][field]")}, "pagination": map[string]interface{}{"page": reqStr.Get("datatable[pagination][page]"), "perpage": reqStr.Get("datatable[pagination][perpage]")}}
	result["datatable"] = datatable
	for k, v := range reqStr {
		if strings.Index(k, "datatable") == -1 {
			result[k] = v[0]
		} else if strings.Index(k, "datatable[sort]") == -1 && strings.Index(k, "datatable[pagination]") == -1 {
			k1 := strings.ReplaceAll(k, "datatable[", "")
			k1 = strings.ReplaceAll(k1, "]", "")
			result[k1] = v[0]
		}
	}
	return result
}

func OriginalCode(password interface{}) string {
	var result string
	pwd := strings.Split(password.(string), "0000")
	if len(pwd) == 2 {
		password2 := pwd[1]
		password2 = password2[len(password2)-(len(password2)/3*3):] //去除前面多余的0
		for i := 0; i < len(password2)/3; i++ {
			number := password2[i*3 : (i+1)*3]
			p, _ := strconv.ParseInt(number, 16, 32)
			result += string(p)
		}
	}
	return result
}

//解析datatable参数为Map对象
func ParseDatatableParam(reqStr string) map[string]interface{} {
	var result = map[string]interface{}{"datatable": map[string]interface{}{}}
	tmp, _ := url.QueryUnescape(reqStr)
	datatable := map[string]interface{}{"sort": map[string]interface{}{"sort": "", "field": ""}, "pagination": map[string]interface{}{"page": 1, "perpage": 20}}
	if strings.HasPrefix(tmp, "datatable") {
		pl := strings.Split(tmp, "&")
		for _, item := range pl {
			vs := strings.Split(item, "=")
			re, _ := regexp.Compile(`\[.*?\]`)
			all := re.FindAll([]byte(vs[0]), -1)
			if len(all) == 1 {
				key := strings.Replace(strings.Replace(string(all[0]), "[", "", 1), "]", "", 1)
				datatable[key] = vs[1]
			} else if len(all) == 2 {
				ele := strings.Replace(strings.Replace(string(all[0]), "[", "", 1), "]", "", 1)
				key := strings.Replace(strings.Replace(string(all[1]), "[", "", 1), "]", "", 1)
				if _, ok := datatable[ele]; ok {
					tmp := datatable[ele].(map[string]interface{})
					tmp[key] = vs[1]
				} else {
					datatable[ele] = map[string]interface{}{key: vs[1]}
				}
			}
		}

		result["datatable"] = datatable
	}
	return result
}

//从请求参数中解析分页数据，组装成SQL格式
func ParsePaginationToSqlPart(param map[string]interface{}, alias ...string) (string, map[string]interface{}) {
	var limit = ""
	var hasfield bool
	var t_alias = ""
	var t_id_alias = "id"
	if alias != nil {
		t_alias = alias[0] + "."
	}
	if alias != nil && len(alias) > 1 {
		t_id_alias = alias[1]
	}
	var meta = map[string]interface{}{"field": "", "sort": "", "page": "1", "pages": "0", "perpage": "1000000", "total": "0"}
	if datatable, ok := param["datatable"]; ok {
		dt := datatable.(map[string]interface{})
		var field, sorttype interface{}
		if sort, hassort := dt["sort"]; hassort {
			sortmap := sort.(map[string]interface{})
			if field, hasfield = sortmap["field"]; !hasfield || IsEmpty(field) == "" {
				field = t_id_alias
			}
			if sorttype, hasfield = sortmap["sort"]; !hasfield || IsEmpty(field) == "" {
				sorttype = "desc"
			}
			meta["field"] = field
			meta["sort"] = sorttype
			limit = limit + " order by " + t_alias + field.(string) + " " + sorttype.(string)
		}
		if pagination, has := dt["pagination"]; has {
			paginationmap := pagination.(map[string]interface{})
			if limit == "" {
				if field, hasfield = paginationmap["field"]; hasfield && IsEmpty(field) != "" {
					if sorttype, hasfield = paginationmap["sort"]; !hasfield || IsEmpty(sorttype) != "" {
						meta["field"] = field
						meta["sort"] = sorttype
						limit = limit + " order by " + t_alias + field.(string) + " " + sorttype.(string)
					}
				}
			}
			var page, perpage interface{}
			if page, hasfield = paginationmap["page"]; !hasfield || IsEmpty(page) == "" {
				page = "1"
			}
			if perpage, hasfield = paginationmap["perpage"]; !hasfield || IsEmpty(perpage) == "" {
				perpage = "50"
			}
			var pageno, pagesize int
			if Typeof(page) == "int" {
				pageno = page.(int)
			} else {
				pageno, _ = strconv.Atoi(page.(string))
			}
			if Typeof(perpage) == "int" {
				pagesize = perpage.(int)
			} else {
				pagesize, _ = strconv.Atoi(perpage.(string))
			}
			meta["page"] = pageno
			meta["perpage"] = pagesize
			//limit = limit + " limit " + strconv.Itoa((pageno-1)*pagesize) + "," + strconv.Itoa(pageno*pagesize)
			limit = limit + " limit " + strconv.Itoa((pageno-1)*pagesize) + "," + strconv.Itoa(pagesize)
		} else {
			limit = limit + " limit 0,1000000"
		}
	}
	return limit, meta
}

//从请求参数中解析分页数据，组装成不包含排序的SQL格式
func ParsePaginationToSqlPartNoOrderBY(param map[string]interface{}, alias ...string) (string, map[string]interface{}) {
	var limit = ""
	var hasfield bool
	var t_alias = ""
	var t_id_alias = ""
	if alias != nil {
		t_alias = alias[0] + "."
	}
	if alias != nil && len(alias) > 1 {
		t_id_alias = alias[1]
	}
	var meta = map[string]interface{}{"field": "", "sort": "", "page": "1", "pages": "0", "perpage": "1000000", "total": "0"}
	if datatable, ok := param["datatable"]; ok {
		dt := datatable.(map[string]interface{})
		var field, sorttype interface{}
		if sort, hassort := dt["sort"]; hassort {
			sortmap := sort.(map[string]interface{})
			if field, hasfield = sortmap["field"]; !hasfield || IsEmpty(field) == "" {
				field = t_id_alias
			}
			if sorttype, hasfield = sortmap["sort"]; !hasfield || IsEmpty(field) == "" {
				sorttype = "desc"
			}
			meta["field"] = field
			meta["sort"] = sorttype
			if field != "" {
				limit = limit + " order by " + t_alias + field.(string) + " " + sorttype.(string)
			}
		}
		if pagination, has := dt["pagination"]; has {
			paginationmap := pagination.(map[string]interface{})
			if limit == "" {
				if field, hasfield = paginationmap["field"]; hasfield && IsEmpty(field) != "" {
					if sorttype, hasfield = paginationmap["sort"]; !hasfield || IsEmpty(sorttype) != "" {
						meta["field"] = field
						meta["sort"] = sorttype
						if field != "" {
							limit = limit + " order by " + t_alias + field.(string) + " " + sorttype.(string)
						}
					}
				}
			}
			var page, perpage interface{}
			if page, hasfield = paginationmap["page"]; !hasfield || IsEmpty(page) == "" {
				page = "1"
			}
			if perpage, hasfield = paginationmap["perpage"]; !hasfield || IsEmpty(perpage) == "" {
				perpage = "50"
			}
			var pageno, pagesize int
			if Typeof(page) == "int" {
				pageno = page.(int)
			} else {
				pageno, _ = strconv.Atoi(page.(string))
			}
			if Typeof(perpage) == "int" {
				pagesize = perpage.(int)
			} else {
				pagesize, _ = strconv.Atoi(perpage.(string))
			}
			meta["page"] = pageno
			meta["perpage"] = pagesize
			//limit = limit + " limit " + strconv.Itoa((pageno-1)*pagesize) + "," + strconv.Itoa(pageno*pagesize)
			limit = " limit " + strconv.Itoa((pageno-1)*pagesize) + "," + strconv.Itoa(pagesize)
		} else {
			limit = limit + " limit 0,1000000"
		}
	}
	return limit, meta
}
func IsUTF8(data []byte) bool {
	var preNUm = func(data byte) int {
		str := fmt.Sprintf("%b", data)
		var i int = 0
		for i < len(str) {
			if str[i] != '1' {
				break
			}
			i++
		}
		return i
	}
	for i := 0; i < len(data); {
		if data[i]&0x80 == 0x00 {
			// 0XXX_XXXX
			i++
			continue
		} else if num := preNUm(data[i]); num > 2 {
			// 110X_XXXX 10XX_XXXX
			// 1110_XXXX 10XX_XXXX 10XX_XXXX
			// 1111_0XXX 10XX_XXXX 10XX_XXXX 10XX_XXXX
			// 1111_10XX 10XX_XXXX 10XX_XXXX 10XX_XXXX 10XX_XXXX
			// 1111_110X 10XX_XXXX 10XX_XXXX 10XX_XXXX 10XX_XXXX 10XX_XXXX
			// preNUm() 返回首个字节的8个bits中首个0bit前面1bit的个数，该数量也是该字符所使用的字节数
			i++
			for j := 0; j < num-1; j++ {
				//判断后面的 num - 1 个字节是不是都是10开头
				if data[i]&0xc0 != 0x80 {
					return false
				}
				i++
			}
		} else {
			//其他情况说明不是utf-8
			return false
		}
	}
	return true
}

func IsGBK(data []byte) bool {
	length := len(data)
	var i int = 0
	for i < length {
		//fmt.Printf("for %x\n", data[i])
		if data[i] <= 0xff {
			//编码小于等于127,只有一个字节的编码，兼容ASCII吗
			i++
			continue
		} else {
			//大于127的使用双字节编码
			if data[i] >= 0x81 &&
				data[i] <= 0xfe &&
				data[i+1] >= 0x40 &&
				data[i+1] <= 0xfe &&
				data[i+1] != 0xf7 {
				i += 2
				continue
			} else {
				return false
			}
		}
	}
	return true
}

func HasChineseChar(str string) bool {
	for _, r := range str {
		if unicode.Is(unicode.Han, r) || (regexp.MustCompile("[\u3002\uff1b\uff0c\uff1a\u201c\u201d\uff08\uff09\u3001\uff1f\u300a\u300b]").MatchString(string(r))) {
			return true
		}
	}
	return false
}

//字节转换成字符，支持中文转换。
//charset:GB18030|UTF-8
func ConvertByte2String(byte []byte, charset string) string {
	var str string
	switch charset {
	case "GB18030":
		var decodeBytes, _ = simplifiedchinese.GB18030.NewDecoder().Bytes(byte)
		str = string(decodeBytes)
	case "UTF-8":
		fallthrough
	default:
		str = string(byte)
	}
	return str
}

//IP verify.支持通配符*
func VerifyIPFormat(ip string) bool {
	if ip == "" {
		return false
	}
	ipParts := strings.Split(ip, ".")
	if len(ipParts) != 3 {
		return false
	}
	for _, v := range ipParts {
		if v != "*" {
			v1, e := strconv.Atoi(v)
			if e != nil {
				return false
			}
			if v1 < 0 || v1 > 255 {
				return false
			}
		}
	}
	return true
}

//email verify
func VerifyEmailFormat(email string) bool {
	pattern := `\w+([-+.]\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*` //匹配电子邮箱
	//pattern := `^[0-9a-z][_.0-9a-z-]{0,31}@([0-9a-z][0-9a-z-]{0,30}[0-9a-z]\.){1,4}[a-z]{2,4}$`
	reg := regexp.MustCompile(pattern)
	return reg.MatchString(email)
}

//mobile verify
func VerifyMobileFormat(mobileNum string) bool {
	regular := "^((13[0-9])|(14[5,7])|(15[0-3,5-9])|(17[0,3,5-8])|(18[0-9])|166|198|199|(147))\\d{8}$"
	reg := regexp.MustCompile(regular)
	return reg.MatchString(mobileNum)
}

func Unzip(zipFile string, destDir string) error {
	zipReader, err := zip.OpenReader(zipFile)
	if err != nil {
		return err
	}
	defer zipReader.Close()
	decodeName := ""
	for _, f := range zipReader.File {
		if f.Flags == 1 {
			//如果标志为是 1 << 11也就是 2048  则是utf-8编码
			decodeName = f.Name
		} else {
			//如果标致位是0或其他  则是默认的本地编码   默认为gbk
			i := bytes.NewReader([]byte(f.Name))
			decoder := transform.NewReader(i, simplifiedchinese.GBK.NewDecoder())
			content, _ := ioutil.ReadAll(decoder)
			decodeName = string(content)
		}
		fpath := filepath.Join(destDir, decodeName)
		if f.FileInfo().IsDir() {
			os.MkdirAll(fpath, os.ModePerm)
		} else {
			if err = os.MkdirAll(filepath.Dir(fpath), os.ModePerm); err != nil {
				return err
			}

			inFile, err := f.Open()
			if err != nil {
				return err
			}
			defer inFile.Close()

			outFile, err := os.OpenFile(fpath, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, f.Mode())
			if err != nil {
				return err
			}
			defer outFile.Close()

			_, err = io.Copy(outFile, inFile)
			if err != nil {
				return err
			}
		}
	}
	return nil
}

func Zip(srcFile string, destZip string) error {
	zipfile, err := os.Create(destZip)
	if err != nil {
		return err
	}
	defer zipfile.Close()

	archive := zip.NewWriter(zipfile)
	defer archive.Close()

	filepath.Walk(srcFile, func(path string, info os.FileInfo, err error) error {
		if err != nil {
			return err
		}

		header, err := zip.FileInfoHeader(info)
		if err != nil {
			return err
		}

		header.Name = strings.TrimPrefix(path, filepath.Dir(srcFile)+string(os.PathSeparator))
		// header.Name = path
		if info.IsDir() {
			header.Name += string(os.PathSeparator)
		} else {
			header.Method = zip.Deflate
		}

		writer, err := archive.CreateHeader(header)
		if err != nil {
			return err
		}

		if !info.IsDir() {
			file, err := os.Open(path)
			if err != nil {
				return err
			}
			defer file.Close()
			_, err = io.Copy(writer, file)
		}
		return err
	})

	return err
}
func ZipMutile(srcFileList []string, destZip string) error {
	zipfile, err := os.OpenFile(destZip, os.O_CREATE|os.O_RDWR|os.O_APPEND, fs.ModePerm)
	if err != nil {
		return err
	}
	defer zipfile.Close()
	//zipfile.Seek(0, os.SEEK_END)
	archive := zip.NewWriter(zipfile)
	defer archive.Close()
	for _, srcFile := range srcFileList {
		filepath.Walk(srcFile, func(path string, info os.FileInfo, err error) error {
			if err != nil {
				return err
			}

			header, err := zip.FileInfoHeader(info)
			if err != nil {
				return err
			}

			header.Name = strings.TrimPrefix(path, filepath.Dir(srcFile)+string(os.PathSeparator))
			// header.Name = path
			if info.IsDir() {
				header.Name += string(os.PathSeparator)
			} else {
				header.Method = zip.Deflate
			}

			writer, err := archive.CreateHeader(header)
			if err != nil {
				return err
			}

			if !info.IsDir() {
				file, err := os.Open(path)
				if err != nil {
					return err
				}
				defer file.Close()
				_, err = io.Copy(writer, file)
			}
			return err
		})
	}
	return err

}

func Utf8ToGBK(text string) (string, error) {
	dst := make([]byte, len(text)*2)
	tr := simplifiedchinese.GB18030.NewEncoder()
	nDst, _, err := tr.Transform(dst, []byte(text), true)
	if err != nil {
		return text, err
	}
	return string(dst[:nDst]), nil
}

//统一删除数据表记录
func DeleteTableReorce(tableName, primaryField, Id string) error {
	o := orm.NewOrm()
	var sqlParameter []interface{}
	var sqlCommandText = "delete from " + tableName + " where " + primaryField + "=?;"
	sqlParameter = append(sqlParameter, Id)
	_, err := o.Raw(sqlCommandText, sqlParameter).Exec()
	return err
}

//获得单条数据记录
func GetSingleRecord(tableName, primaryField, Id string) ([]orm.Params, error) {
	o := orm.NewOrm()
	var sqlParameter []interface{}
	var sqlCommandText string
	if tableName == "t_data_monitor_task" {
		sqlCommandText = "select a.*,tr.path checkreport,u.name adminusername,s.name stationname,sc1.name switchgear_one_name,sc2.name switchgear_two_name,sc3.name switchgear_comp_name,(select tpl_name from t_data_config_tpl where id=a.tpl) tplname " +
			"from t_data_monitor_task a left join t_data_user u on a.adminuser=u.id inner join t_data_station s on a.stationid=s.stationid left join t_data_switchgear sc1 on a.switchgear_one=sc1.id  left join t_data_switchgear sc2 on a.switchgear_two=sc2.id  left join t_data_switchgear sc3 on a.switchgear_comp=sc3.id left join t_data_monitor_report tr on a.id=tr.taskid where a.id=?"
		sqlParameter = append(sqlParameter, Id)
	} else {
		sqlCommandText = "select * from " + tableName + " where " + primaryField + "=?;"
		sqlParameter = append(sqlParameter, Id)
	}

	var tableData []orm.Params
	_, err := o.Raw(sqlCommandText, sqlParameter).Values(&tableData)
	return tableData, err
}

func LocalIPv4() (string, error) {
	ifaces, err := net.Interfaces()
	if err != nil {
		return "", err
	}
	for _, iface := range ifaces {
		if iface.Flags&net.FlagUp == 0 {
			continue
		}
		if iface.Flags&net.FlagLoopback != 0 {
			continue
		}
		addrs, err := iface.Addrs()
		if err != nil {
			return "", err
		}
		for _, addr := range addrs {
			var ip net.IP
			switch v := addr.(type) {
			case *net.IPNet:
				ip = v.IP
			case *net.IPAddr:
				ip = v.IP
			}
			if ip == nil || ip.IsLoopback() {
				continue
			}
			ip = ip.To4()
			if ip == nil {
				continue
			}
			return ip.String(), nil
		}
	}
	return "", errors.New("未连接网络")
}

//获取当前运行程序版本号
func GetVersion() string {
	exename := conf.GlobalConfig["appid"]
	if exename == "" {
		logger.Logger.Println("系统还未配置appid属性，请正确设置后再试！")
		os.Exit(0)
		return ""
	}
	if string(runtime.GOOS) == "windows" {
		exename = exename + ".exe"
	}
	f, err1 := os.Open(exename)
	if err1 != nil {
		logger.Logger.Println("获取版本号失败,请检查appid是否与程序名称匹配！")
		logger.Logger.Error(err1)
		os.Exit(0)
		return ""
	}
	fi, err2 := f.Stat()
	if err2 != nil {
		logger.Logger.Info("获取版本号失败:")
		logger.Logger.Error(err2)
		return ""
	}
	return fi.ModTime().Format("20060102-15")
}

func GetAppCurPath() string {
	file, _ := exec.LookPath(os.Args[0])
	execpath, _ := filepath.Abs(file)
	execpath = filepath.Dir(execpath)
	if execpath[len(execpath)-1:] != string(os.PathSeparator) {
		execpath = execpath + string(os.PathSeparator)
	}
	return execpath
}