Merge branch 'master' of http://git.shengws.com/csx/gdyb

conf/app.conf

 
 
 [prod]
-org_id = 10215
+org_id = 10188
 mobile_token_expiration_second = 86400
 httpdomain = https://api.xt.kuyicloud.com
 sso_domain = https://sso.kuyicloud.com
 # gdyb_url="http://igb.hsa.gdgov.cn/ebus/sz_prd/hsa/hgs/"
 #内蒙古
 # gdyb_url = "http://10.38.23.105:8090/uif-hsaf-med-api/api/medical/service/"
-# gdyb_paasid = "sg03_prd"
+gdyb_paasid = "sg03_prd"
 # gdyb_paasid = "jm_sc_yjyy"
 #gdyb_paasid="zh_prd_yrojyy"
 #gdyb_paasid = "sz_prd_yjyy"
-gdyb_paasid = "zq_prd_yjyy"
+# gdyb_paasid = "zq_prd_yjyy"
 
 
 

main.go

 	"fmt"
 	"gdyb/models"
 	_ "gdyb/routers"
-	"gdyb/service"
 	"github.com/astaxie/beego"
 	"github.com/qiniu/api.v7/auth/qbox"
 	"github.com/qiniu/api.v7/storage"
 )
 
 func init() {
-	service.ConnectDB()
-	org_id, _ := beego.AppConfig.Int64("org_id")
-	miConfig, _ := service.FindMedicalInsuranceInfo(org_id)
-	CreateLog(miConfig)
-	UploadLog(miConfig)
+	//service.ConnectDB()
+	//org_id, _ := beego.AppConfig.Int64("org_id")
+	//miConfig, _ := service.FindMedicalInsuranceInfo(org_id)
+	//CreateLog(miConfig)
+	//UploadLog(miConfig)
 
 }
 func main() {

service/jsyb_service.go

 package service
 
 import (
-	"bytes"
 	"crypto/hmac"
 	"crypto/sha1"
 	"encoding/base64"
 	"encoding/json"
 	"fmt"
 	"gdyb/utils/csbhttp"
-	"io/ioutil"
-	"net/http"
 	"strconv"
 	"time"
 )
 	input["data"] = inputData
 	inputMessage["input"] = input //交易输入
 
-	var inputLog string
+	//var inputLog string
 	bytesData, _ := json.Marshal(inputMessage)
-	inputLog = string(bytesData)
+	//inputLog = string(bytesData)
 	fmt.Println(string(bytesData))
 	if err != nil {
 		fmt.Println(err.Error())
 		return err.Error(), ""
 	}
-	reader := bytes.NewReader(bytesData)
+	//reader := bytes.NewReader(bytesData)
 
-	request, err := http.NewRequest("POST", "http://10.72.3.87:8086/CSB/1101", reader)
-	if err != nil {
-		fmt.Println(err.Error())
-		return err.Error(), ""
-	}
+	//request, err := http.NewRequest("POST", "http://10.72.3.87:8086/CSB/1101", reader)
+	//if err != nil {
+	//	fmt.Println(err.Error())
+	//	return err.Error(), ""
+	//}
 	//key := "_api_access_key=" + access_key + "&_api_name=" + "hssServives" + "&_api_timestamp=" + strconv.FormatInt(timestamp, 10) + "&_api_version=" + "1.0.0"
 
-	fmt.Println(skey)
-	fmt.Println(timestamp_str)
-	fmt.Println(access_key)
-
-	request.Header.Set("Content-Type", "application/json")
-	request.Header.Set("_api_timestamp", timestamp_str)
-	request.Header.Set("_api_name", "hssServives")
-	request.Header.Set("_api_version", "1.0.0")
-	request.Header.Set("_api_access_key", access_key)
-	request.Header.Set("_api_signature", skey)
-
-	client := http.Client{}
-	resp, err := client.Do(request)
-	if err != nil {
-		fmt.Println(err.Error())
-		return err.Error(), ""
-	}
-	respBytes, err := ioutil.ReadAll(resp.Body)
-	if err != nil {
-		fmt.Println(err.Error())
-		return err.Error(), ""
-	}
-	fmt.Println(string(respBytes))
-	str := string(respBytes)
-	return str, inputLog
+	//fmt.Println(skey)
+	//fmt.Println(timestamp_str)
+	//fmt.Println(access_key)
+	//
+	//request.Header.Set("Content-Type", "application/json")
+	//request.Header.Set("_api_timestamp", timestamp_str)
+	//request.Header.Set("_api_name", "hssServives")
+	//request.Header.Set("_api_version", "1.0.0")
+	//request.Header.Set("_api_access_key", access_key)
+	//request.Header.Set("_api_signature", skey)
+	//
+	//client := http.Client{}
+	//resp, err := client.Do(request)
+	//if err != nil {
+	//	fmt.Println(err.Error())
+	//	return err.Error(), ""
+	//}
+	//respBytes, err := ioutil.ReadAll(resp.Body)
+	//if err != nil {
+	//	fmt.Println(err.Error())
+	//	return err.Error(), ""
+	//}
+	//fmt.Println(string(respBytes))
+	//str := string(respBytes)
+	//return str, inputLog
 	//request_url = "http://10.72.3.87:8086/CSB/1101"
-	//return HttpRequest(request_url, access_key, secret_key, timestamp, bytesData, string(bytesData)), ""
+	return HttpRequest(request_url, access_key, secret_key, timestamp, bytesData, string(bytesData)), ""
 }
 func HttpRequest(url string, ak string, sk string, timestamp int64, requestByte []byte, json string) string {
 	fmt.Println(url)
 	//打印请求参数信息
 	csbHP.Print()
 	//进行调用, 返回的第二项为resonse http headers (map[string][]string类型)
-	res, _, err := csbhttp.Invoke(*csbHP, requestByte)
+	//res, _, err := csbhttp.Invoke(*csbHP, requestByte)
+	res, _, err := csbhttp.Invoke(*csbHP)
 	//是否发成错误
 	if err != nil {
 		fmt.Println(err)

utils/csbhttp/httpcaller.go

 package csbhttp
 
 import (
+	"fmt"
+	//"crypto/tls"
 	"bytes"
 	"encoding/json"
-	"fmt"
 	"io/ioutil"
 	"net"
 	"net/http"
 	"strconv"
 	"strings"
 	"sync"
-	//"crypto/tls"
 	"time"
 )
 
 */
 func signParams(params map[string]string, api string, version string, ak string, sk string) (headMaps map[string]string) {
 	headMaps = make(map[string]string)
-	fmt.Println("sk=" + sk)
+
 	params[API_NAME_KEY] = api
 	headMaps[API_NAME_KEY] = api
 
 当处理正常时,异常为nil
 
 */
-func Invoke(params HttpParams, bytesData []byte) (str string, rtnHeaders map[string][]string, hcError *HttpCallerException) {
+func Invoke(params HttpParams) (str string, rtnHeaders map[string][]string, hcError *HttpCallerException) {
 	//init rtnHeaders
 	rtnHeaders = make(map[string][]string)
 
 	}
 
 	reqUrl := params.requestUrl
-	//defaultContentType := "application/x-www-form-urlencoded"
-	fmt.Println("打印开始")
-	fmt.Println(params.ct.jsonBody)
-	fmt.Println(reqUrl)
-	fmt.Println(params)
-	fmt.Println(params.ct.bytesBody)
 
+	defaultContentType := "application/x-www-form-urlencoded"
 	if params.ct.jsonBody != "" {
 		_, err = json.Marshal(params.ct.jsonBody)
-		//if err == nil {
-		//	return str, rtnHeaders, &HttpCallerException{Message: "failed to bad content type json string", CauseErr: err}
-		//}
+		if err == nil {
+			return str, rtnHeaders, &HttpCallerException{Message: "failed to bad content type json string", CauseErr: err}
+		}
 		reqStr = params.ct.jsonBody
-		//defaultContentType = "application/json;charset=UTF-8"
+		defaultContentType = params.ct.contentType
 		reqUrl = appendParams(reqUrl, data.Encode())
 	} else if params.ct.bytesBody != nil {
 		reqStr = string(params.ct.bytesBody)
-		//defaultContentType = params.ct.contentType
+		defaultContentType = params.ct.contentType
 		reqUrl = appendParams(reqUrl, data.Encode())
 	} else {
 		reqStr = data.Encode()
 	}
 
-	fmt.Println("打印开始1")
-	fmt.Println(reqStr)
-	fmt.Println(method)
-	fmt.Println(reqUrl)
-	fmt.Println(bytesData)
-	fmt.Println(string(bytesData))
-
-	req, err := http.NewRequest(method, reqUrl, bytes.NewReader(bytesData))
-
-	fmt.Println("打印开始2")
-	fmt.Println(req)
+	req, err := http.NewRequest(method, reqUrl, bytes.NewBufferString(reqStr))
 
 	if err != nil {
 		return str, rtnHeaders, &HttpCallerException{Message: "failed to construct http post request", CauseErr: err}
 	signHeaders := signParams(urlParams, params.api, params.version, params.ak, params.sk)
 	printDebug("signHeaders", signHeaders)
 
-	req.Header.Add("Content-Type", "application/json;charset=UTF-8")
+	req.Header.Add("Content-Type", defaultContentType)
 	if params.headers != nil {
 		for k, v := range params.headers {
 			req.Header.Add(k, v)
 	}
 
 	//client.Timeout
-	req.Close = true
 	resp, err := client.Do(req)
 
 	if err != nil {
-		fmt.Println(err)
 		return str, rtnHeaders, &HttpCallerException{Message: "failed to invoke http post", CauseErr: err}
 	}
 

utils/csbhttp/httpparams.go

 */
 package csbhttp
 
+import ()
 import (
 	"encoding/json"
 	"fmt"
 }
 
 func (hp *HttpParams) SetContentBody(jsonStr string, byteArr []byte) error {
-
-	//if jsonStr != "" && byteArr != nil {
-	//	fmt.Println("11111112222222")
-	//
-	//	errRtn := HttpCallerException{Message: "can not set jsonStr and byteArr parameters together!"}
-	//	return errRtn
-	//}
+	if jsonStr != "" && byteArr != nil {
+		errRtn := HttpCallerException{Message: "can not set jsonStr and byteArr parameters together!"}
+		return errRtn
+	}
 
 	if jsonStr != "" {
-		fmt.Println("333333334444444")
-
 		hp.ct.jsonBody = jsonStr
 		hp.ct.contentType = JSON
 	}
 
 	if byteArr != nil {
-		fmt.Println("5555556666666")
-
 		hp.ct.bytesBody = byteArr //TODO: copy or pointer ?
 		hp.ct.contentType = BINARY
 	}
-	fmt.Println("------")
-	fmt.Println(hp.ct.jsonBody)
-	fmt.Println(hp.ct.bytesBody)
-	fmt.Println("------")
 
 	return nil
 }

utils/csbhttp/signutil.go

 	"crypto/hmac"
 	"crypto/sha1"
 	"encoding/base64"
-	"fmt"
 	"hash"
 	"io"
 	"sort"
 
 // 做签名处理
 func doSign(params map[string]string, secretKey string) string {
-	fmt.Println("params")
-	fmt.Println(params)
-
-	fmt.Println("secretKey")
-	fmt.Println(secretKey)
-
 	hs := newParamsSorter(params)
 
-	fmt.Println("hs")
-	fmt.Println(hs)
-
 	// Sort the temp by the Ascending Order
 	hs.Sort()