jx-callback/controllers/api_controller.go

package controllers

import (
	"encoding/hex"
	"encoding/json"
	"fmt"
	"git.rosy.net.cn/baseapi/utils"
	"git.rosy.net.cn/jx-callback/business/model"
	"git.rosy.net.cn/jx-callback/globals"
	"github.com/astaxie/beego/server/web"
	"net"
	"net/url"
	"os"
	"reflect"
	"strconv"
)

type ApiController struct {
	web.Controller
}

const (
	keyAppID     = "app_id"
	keyTimestamp = "timestamp"
	keyMethod    = "method"
	keySign      = "sign"
)

var (
	routerMap map[string]reflect.Value
	textChan  chan string
)

func Init() {
	routerMap = make(map[string]reflect.Value)
	var ruTest ApiController
	vf := reflect.ValueOf(&ruTest)
	vft := vf.Type()
	//读取方法数量
	mNum := vf.NumMethod()
	fmt.Println("mNum", mNum)
	//遍历路由器的方法，并将其存入控制器映射变量中
	for i := 0; i < mNum; i++ {
		mName := vft.Method(i).Name
		routerMap[mName] = vf.Method(i)
	}
}

// @Title api调用入口
// @Description api调用入口
// @Param	app_id		formData	string	 false	"应用ID"
// @Param	timestamp	formData	int64	 false	"unix时间戳"
// @Param	sign		formData	string	 false	"签名"
// @Param	method		formData	string	 false	"接口名"
// @Success 200 {object} controllers.CallResult
// @Failure 200 {object} controllers.CallResult
// @router /CallOpenAPI [post]
func (c *ApiController) CallOpenAPI() {
	var (
		err           error
		errCode       = model.ErrCodeGeneralFailed
		callResult    = &CallResult{}
		accessID      = utils.GetUUID()
		requireParams []string
		dataMap       = make(map[string]interface{})
		//now           = time.Now().Unix()
		parms, result []reflect.Value
		urls          url.Values
	)
	var (
		appID, sign, method string
		//timestamp           int64
	)
	//判断必传参数是否传入begin
	if appID = c.GetString(keyAppID); appID == "" {
		requireParams = append(requireParams, keyAppID)
	}
	if method = c.GetString(keyMethod); method == "" {
		requireParams = append(requireParams, keyMethod)
	}
	if sign = c.GetString(keySign); sign == "" {
		requireParams = append(requireParams, keySign)
	}
	//if timestamp, err = c.GetInt64("timestamp"); err != nil {
	//	requireParams = append(requireParams, "timestamp")
	//}
	if len(requireParams) > 0 {
		err = buildParamRequiredErr(requireParams)
	}
	//判断必传参数是否传入end
	if err != nil {
		goto end
	}
	//判断timestamp传入是否正确begin
	//if len(utils.Int64ToStr(timestamp)) != len(utils.Int64ToStr(now)) {
	//	err = buildTimestampParamErr()
	//	errCode = model.ErrCodeOpenAPIParamErrTimeStamp
	//}
	//if now-timestamp < 5 {
	//	err = buildTimestampParamErr()
	//	errCode = model.ErrCodeOpenAPIParamErrTimeStamp
	//}
	//判断timestamp传入是否正确end
	if err != nil {
		goto end
	}
	//判断app_id和sign匹配begin

	//判断app_id和sign匹配end
	//call
	urls, _ = c.Input()
	dataMap = utils.URLValues2Map(urls)
	delete(dataMap, keyAppID)
	delete(dataMap, keyMethod)
	delete(dataMap, keyTimestamp)
	parms = []reflect.Value{reflect.ValueOf(dataMap)}
	if routerMap[method] == reflect.ValueOf(nil) {
		errCode = model.ErrCodeOpenAPIParamErrMethod
		err = buildMethodParamErr()
	}
	globals.SugarLogger.Debugf("Begin API CallOpenAPI Method: %s, accessUUID:%s, sign:%s\n", method, accessID, sign)
	if err == nil {
		result = routerMap[method].Call(parms)
		if !result[1].IsNil() {
			err = fmt.Errorf(result[1].String())
			goto end
		}
		goto success
	} else {
		callResult.Code = errCode
		callResult.Desc = err.Error()
	}
end:
	{
		callResult.Code = errCode
		callResult.Desc = err.Error()
		c.Data["json"] = callResult
		c.ServeJSON()
	}
success:
	{
		callResult.Code = model.ErrCodeSuccess
		callResult.Data = result[0].String()
		c.Data["json"] = callResult
		c.ServeJSON()
	}
}

func (c *ApiController) AddPrint(dataMap map[string]interface{}) (data string, err error) {
	if dataMap[keySign].(string) != "222" {
		return "", buildParamErr(keySign)
	}
	data2, err := json.Marshal(dataMap)
	return string(data2), err
}

func (c *ApiController) DoPrint(dataMap map[string]interface{}) (data string, err error) {
	data = dataMap["data"].(string)
	server := "print.jxcs.net:8000"
	tcpAddr, err := net.ResolveTCPAddr("tcp4", server)
	if err != nil {
		fmt.Fprintf(os.Stderr, "Fatal error: %s", err.Error())
		os.Exit(1)
	}
	conn, err := net.DialTCP("tcp", nil, tcpAddr)
	if err != nil {
		return
	}
	textChan = make(chan string, 10)
	textChan <- data
	go connHandler(conn)
	return data, err
}

func connHandler(c net.Conn) {
	str := "1e"
	const1 := "0200ff50"
	orderNo := "0001"     //订单序列号
	printInit := "1b40"   //打印机初始化
	voice := "1b59415501" //语音响一次
	check := "ff"
	go func() {
		s := <-textChan
		//写入数据
		printData := hex.EncodeToString([]byte(s))
		lenData := int64(len(str) + len(const1) + len(orderNo) + len(printInit) + len(voice) + 1 + 2 + len(printData))
		x1, x2 := int2h8l8(lenData / 2)
		data := str + x1 + x2 + const1 + orderNo + printInit + voice + printData + check
		n, err := c.Write([]byte(data))
		if err != nil {
			fmt.Println("Write err:", err, n)
			return
		}
	}()
}

func int2h8l8(i int64) (h, l string) {
	origin2 := fmt.Sprintf("%b", i)
	flag := 16 - len(origin2)
	for i := 0; i < flag; i++ {
		origin2 = "0" + origin2
	}
	begin8 := origin2[:8]
	end8 := origin2[8:]
	r1, _ := strconv.ParseInt(begin8, 2, 32)
	r2, _ := strconv.ParseInt(end8, 2, 32)
	h = fmt.Sprintf("%x", r1)
	l = fmt.Sprintf("%x", r2)
	if len(h) < 2 {
		h = "0" + h
	}
	if len(l) < 2 {
		l = "0" + l
	}
	return h, l
}