SmartCanteen
/
smart_canteen
2
0
Fork 0
Koodi Ongelmat 0 Pull-pyynnöt 0 Julkaisut 0 Wiki Toiminta
智慧食堂
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
290 Commitit
5 Branchit
8.2 MiB
 
 
Puu: 2e0b8dc939
Branchit Tagit
${ item.name }
Create branch ${ searchTerm }
from '2e0b8dc939'
${ noResults }
smart_canteen/app/customer/svc/svc_pay.go

505 rivejä
16 KiB
Raaka Blame Historia 

  1. package svc

  2. 

  3. import (

  4. 	"applet/app/customer/enum"

  5. 	"applet/app/customer/md"

  6. 	"applet/app/db"

  7. 	"applet/app/db/model"

  8. 	enum2 "applet/app/enum"

  9. 	svc3 "applet/app/svc"

  10. 	"applet/app/utils"

  11. 	"applet/app/utils/logx"

  12. 	"encoding/json"

  13. 	"errors"

  14. 	"fmt"

  15. 	"github.com/gin-gonic/gin"

  16. 	"github.com/wechatpay-apiv3/wechatpay-go/core"

  17. 	"github.com/wechatpay-apiv3/wechatpay-go/services/partnerpayments/jsapi"

  18. 	"io/ioutil"

  19. 	"net/url"

  20. 	"time"

  21. )

  22. 

  23. func BuyPackageForAli(c *gin.Context, req md.BuyPackageReq) (outTradeNo, tradeNo, total string, err error) {

  24. 	user := GetUser(c)

  25. 	session := db.Db.NewSession()

  26. 	defer session.Close()

  27. 	session.Begin()

  28. 	if err != nil {

  29. 		_ = session.Rollback()

  30. 		return

  31. 	}

  32. 

  33. 	//1、判断是否为教师

  34. 	isTeacher := false

  35. 	userIdentityDb := db.UserIdentityDb{}

  36. 	userIdentityDb.Set(0)

  37. 	userIdentity, err := userIdentityDb.GetUserIdentity(req.UserIdentityId)

  38. 	if err != nil {

  39. 		return

  40. 	}

  41. 	if userIdentity == nil {

  42. 		err = errors.New("未查询到对应身份记录")

  43. 		return

  44. 	}

  45. 	if userIdentity.Identity == enum2.UserIdentityForCentralKitchenForTeacher {

  46. 		isTeacher = true

  47. 	}

  48. 

  49. 	//2、计算数据(1:按学期购买 2:按月购买 3:按天购买 4:补餐)

  50. 	var totalPrice float64

  51. 	var data []*model.CentralKitchenForSchoolUserWithDay

  52. 	if req.Kind == 1 {

  53. 		totalPrice, data, err = CalcBySchoolTerm(user.Id, isTeacher, req)

  54. 		if err != nil {

  55. 			return

  56. 		}

  57. 	}

  58. 	if req.Kind == 2 {

  59. 		totalPrice, data, err = CalcByMonth(user.Id, isTeacher, req)

  60. 		if err != nil {

  61. 			return

  62. 		}

  63. 	}

  64. 	if req.Kind == 3 {

  65. 		totalPrice, data, err = CalcByDay(user.Id, isTeacher, req)

  66. 		if err != nil {

  67. 			return

  68. 		}

  69. 	}

  70. 	if req.Kind == 4 {

  71. 		totalPrice, data, err = CalcSupplementaryByDay(user.Id, isTeacher, req)

  72. 		if err != nil {

  73. 			return

  74. 		}

  75. 	}

  76. 	total = utils.Float64ToStr(totalPrice)

  77. 

  78. 	//3、生成订单号

  79. 	outTradeNo = utils.OrderUUID(user.Id)

  80. 

  81. 	//4、请求 alipay.trade.create(统一收单交易创建接口)

  82. 	sysCfgDb := db.SysCfgDb{}

  83. 	sysCfgDb.Set()

  84. 	sysCfg := sysCfgDb.SysCfgFindWithDb(enum2.OpenAppletAppid, enum2.OpenAlipayAppid, enum2.OpenAlipayAppPrivateKey, enum2.OpenAlipayPublicKey, enum2.JsapiPayAppAutToken, enum2.JsapiPayNotifyUrl)

  85. 	err, resp := CurlAlipayTradeCreate(md.CurlAlipayTradeCreateReq{

  86. 		Config: struct {

  87. 			PayAliAppId      string `json:"pay_ali_app_id" label:"支付宝开放平台-第三方应用-appid"`

  88. 			PayAliPrivateKey string `json:"pay_ali_private_key" label:"支付宝开放平台-第三方应用-接口加签-应用私钥"`

  89. 			PayAliPublicKey  string `json:"pay_ali_public_key" label:"支付宝开放平台-第三方应用-接口加签-支付宝公钥"`

  90. 		}{

  91. 			PayAliAppId:      sysCfg[enum2.OpenAlipayAppid],

  92. 			PayAliPrivateKey: sysCfg[enum2.OpenAlipayAppPrivateKey],

  93. 			PayAliPublicKey:  sysCfg[enum2.OpenAlipayPublicKey],

  94. 		},

  95. 		OpAppId:      sysCfg[enum2.OpenAppletAppid],

  96. 		BuyerId:      user.UserId,

  97. 		TotalAmount:  total,

  98. 		OutTradeNo:   outTradeNo,

  99. 		Subject:      "购买食堂套餐",

  100. 		AppAuthToken: sysCfg[enum2.JsapiPayAppAutToken],

  101. 		NotifyUrl:    sysCfg[enum2.JsapiPayNotifyUrl],

  102. 	})

  103. 	if err != nil {

  104. 		return

  105. 	}

  106. 

  107. 	//5、插入订单记录

  108. 	now := time.Now()

  109. 	centralKitchenForSchoolPackageOrd := db.CentralKitchenForSchoolPackageOrd{}

  110. 	centralKitchenForSchoolPackageOrd.Set(outTradeNo)

  111. 	_, err = centralKitchenForSchoolPackageOrd.CentralKitchenForSchoolPackageOrdInsertBySession(session, &model.CentralKitchenForSchoolPackageOrd{

  112. 		EnterpriseId:     req.EnterpriseId,

  113. 		Uid:              user.Id,

  114. 		UserIdentityId:   req.UserIdentityId,

  115. 		UserIdentityName: userIdentity.Name,

  116. 		TotalPrice:       total,

  117. 		Kind:             req.Kind,

  118. 		OutTradeNo:       outTradeNo,

  119. 		TradeNo:          resp.TradeNo,

  120. 		State:            enum2.CentralKitchenForSchoolPackageOrdStateForWait,

  121. 		OrdState:         enum2.CentralKitchenForSchoolPackageOrdOrdStateForWait,

  122. 		ReqContent:       string(utils.Serialize(req)),

  123. 		WithDayData:      string(utils.Serialize(data)),

  124. 		PayWay:           enum.PayWayForAli,

  125. 		CreateAt:         now.Format("2006-01-02 15:04:05"),

  126. 		UpdateAt:         now.Format("2006-01-02 15:04:05"),

  127. 	})

  128. 	if err != nil {

  129. 		_ = session.Rollback()

  130. 		return

  131. 	}

  132. 	session.Commit()

  133. 	tradeNo = resp.TradeNo

  134. 	return

  135. }

  136. 

  137. func BuyPackageForWx(c *gin.Context, req md.BuyPackageReq) (outTradeNo, prepayId, total string, err error) {

  138. 	user := GetUser(c)

  139. 	session := db.Db.NewSession()

  140. 	defer session.Close()

  141. 	session.Begin()

  142. 	if err != nil {

  143. 		_ = session.Rollback()

  144. 		return

  145. 	}

  146. 

  147. 	//1、判断是否为教师

  148. 	isTeacher := false

  149. 	userIdentityDb := db.UserIdentityDb{}

  150. 	userIdentityDb.Set(0)

  151. 	userIdentity, err := userIdentityDb.GetUserIdentity(req.UserIdentityId)

  152. 	if err != nil {

  153. 		return

  154. 	}

  155. 	if userIdentity == nil {

  156. 		err = errors.New("未查询到对应身份记录")

  157. 		return

  158. 	}

  159. 	if userIdentity.Identity == enum2.UserIdentityForCentralKitchenForTeacher {

  160. 		isTeacher = true

  161. 	}

  162. 

  163. 	//2、计算数据(1:按学期购买 2:按月购买 3:按天购买 4:补餐)

  164. 	var totalPrice float64

  165. 	var data []*model.CentralKitchenForSchoolUserWithDay

  166. 	if req.Kind == 1 {

  167. 		totalPrice, data, err = CalcBySchoolTerm(user.Id, isTeacher, req)

  168. 		if err != nil {

  169. 			return

  170. 		}

  171. 	}

  172. 	if req.Kind == 2 {

  173. 		totalPrice, data, err = CalcByMonth(user.Id, isTeacher, req)

  174. 		if err != nil {

  175. 			return

  176. 		}

  177. 	}

  178. 	if req.Kind == 3 {

  179. 		totalPrice, data, err = CalcByDay(user.Id, isTeacher, req)

  180. 		if err != nil {

  181. 			return

  182. 		}

  183. 	}

  184. 	if req.Kind == 4 {

  185. 		totalPrice, data, err = CalcSupplementaryByDay(user.Id, isTeacher, req)

  186. 		if err != nil {

  187. 			return

  188. 		}

  189. 	}

  190. 	total = utils.Float64ToStr(totalPrice)

  191. 

  192. 	//3、生成订单号

  193. 	outTradeNo = utils.OrderUUID(user.Id)

  194. 

  195. 	//4、请求 /v3/pay/partner/transactions/jsapi (生成预支付交易单)

  196. 	sysCfgDb := db.SysCfgDb{}

  197. 	sysCfgDb.Set()

  198. 	client, err := svc3.NewWxPayClient(c)

  199. 	if err != nil {

  200. 		return

  201. 	}

  202. 	wxSvc := jsapi.JsapiApiService{Client: client}

  203. 	sysCfg := sysCfgDb.SysCfgFindWithDb(enum2.WxSpAppId, enum2.WxSpMchId, enum2.WxAppletAppId, enum2.WxMchId, enum2.WxJsapiPayNotifyUrl)

  204. 

  205. 	resp, _, err := wxSvc.Prepay(c,

  206. 		jsapi.PrepayRequest{

  207. 			SpAppid:     core.String(sysCfg[enum2.WxSpAppId]),

  208. 			SpMchid:     core.String(sysCfg[enum2.WxSpMchId]),

  209. 			SubAppid:    core.String(sysCfg[enum2.WxAppletAppId]),

  210. 			SubMchid:    core.String(sysCfg[enum2.WxMchId]),

  211. 			Description: core.String("购买食堂套餐"),

  212. 			OutTradeNo:  core.String(outTradeNo),

  213. 			TimeExpire:  core.Time(time.Now().Add(30 * time.Minute)),

  214. 			//Attach:      core.String("自定义数据说明"),

  215. 			NotifyUrl: core.String(sysCfg[enum2.WxJsapiPayNotifyUrl]),

  216. 			Amount: &jsapi.Amount{

  217. 				Currency: core.String("CNY"),

  218. 				Total:    core.Int64(int64(totalPrice * 100)),

  219. 			},

  220. 			Payer: &jsapi.Payer{

  221. 				//SpOpenid:  core.String("oUpF8uMuAJO_M2pxb1Q9zNjWeS6o"),

  222. 				SubOpenid: core.String(user.OpenId),

  223. 			},

  224. 		},

  225. 	)

  226. 

  227. 	fmt.Println(">>>>>>>>>>>", core.Int64(utils.StrToInt64(total)*100))

  228. 	if err != nil {

  229. 		_ = session.Rollback()

  230. 		return

  231. 	}

  232. 

  233. 	//5、插入订单记录

  234. 	now := time.Now()

  235. 	centralKitchenForSchoolPackageOrd := db.CentralKitchenForSchoolPackageOrd{}

  236. 	centralKitchenForSchoolPackageOrd.Set(outTradeNo)

  237. 	_, err = centralKitchenForSchoolPackageOrd.CentralKitchenForSchoolPackageOrdInsertBySession(session, &model.CentralKitchenForSchoolPackageOrd{

  238. 		EnterpriseId:     req.EnterpriseId,

  239. 		Uid:              user.Id,

  240. 		UserIdentityId:   req.UserIdentityId,

  241. 		UserIdentityName: userIdentity.Name,

  242. 		TotalPrice:       total,

  243. 		Kind:             req.Kind,

  244. 		OutTradeNo:       outTradeNo,

  245. 		TradeNo:          "",

  246. 		State:            enum2.CentralKitchenForSchoolPackageOrdStateForWait,

  247. 		OrdState:         enum2.CentralKitchenForSchoolPackageOrdOrdStateForWait,

  248. 		ReqContent:       string(utils.Serialize(req)),

  249. 		WithDayData:      string(utils.Serialize(data)),

  250. 		PayWay:           enum.PayWayForWx,

  251. 		CreateAt:         now.Format("2006-01-02 15:04:05"),

  252. 		UpdateAt:         now.Format("2006-01-02 15:04:05"),

  253. 	})

  254. 	if err != nil {

  255. 		_ = session.Rollback()

  256. 		return

  257. 	}

  258. 	session.Commit()

  259. 	prepayId = *resp.PrepayId

  260. 	return

  261. }

  262. 

  263. func NursingHomeBuyPackageReq(c *gin.Context, req md.NursingHomeBuyPackageReq) (outTradeNo, tradeNo, total string, err error) {

  264. 	user := GetUser(c)

  265. 	session := db.Db.NewSession()

  266. 	defer session.Close()

  267. 	session.Begin()

  268. 	if err != nil {

  269. 		_ = session.Rollback()

  270. 		return

  271. 	}

  272. 

  273. 	userIdentityDb := db.UserIdentityDb{}

  274. 	userIdentityDb.Set(0)

  275. 	userIdentity, err := userIdentityDb.GetUserIdentity(req.UserIdentityId)

  276. 	if err != nil {

  277. 		return

  278. 	}

  279. 	if userIdentity == nil {

  280. 		err = errors.New("未查询到对应身份记录")

  281. 		return

  282. 	}

  283. 

  284. 	//1、计算数据(1:按年购买 2:按月购买 3:按天购买 4:补餐)

  285. 	var totalPrice float64

  286. 	var data []*model.NursingHomeUserWithDay

  287. 	if req.Kind == 1 {

  288. 		totalPrice, data, err = CalcByYearForNursingHome(user.Id, req)

  289. 		if err != nil {

  290. 			return

  291. 		}

  292. 	}

  293. 	if req.Kind == 2 {

  294. 		totalPrice, data, err = CalcByMonthForNursingHome(user.Id, req)

  295. 		if err != nil {

  296. 			return

  297. 		}

  298. 	}

  299. 	if req.Kind == 3 {

  300. 		totalPrice, data, err = CalcByDayForNursingHome(user.Id, req)

  301. 		if err != nil {

  302. 			return

  303. 		}

  304. 	}

  305. 	if req.Kind == 4 {

  306. 		totalPrice, data, err = CalcByDayForNursingHome(user.Id, req)

  307. 		if err != nil {

  308. 			return

  309. 		}

  310. 	}

  311. 	total = utils.Float64ToStr(totalPrice)

  312. 

  313. 	//3、生成订单号

  314. 	outTradeNo = utils.OrderUUID(user.Id)

  315. 

  316. 	//4、请求 alipay.trade.create(统一收单交易创建接口)

  317. 	sysCfgDb := db.SysCfgDb{}

  318. 	sysCfgDb.Set()

  319. 	sysCfg := sysCfgDb.SysCfgFindWithDb(enum2.OpenAppletAppid, enum2.OpenAlipayAppid, enum2.OpenAlipayAppPrivateKey, enum2.OpenAlipayPublicKey, enum2.JsapiPayAppAutToken)

  320. 	err, resp := CurlAlipayTradeCreate(md.CurlAlipayTradeCreateReq{

  321. 		Config: struct {

  322. 			PayAliAppId      string `json:"pay_ali_app_id" label:"支付宝开放平台-第三方应用-appid"`

  323. 			PayAliPrivateKey string `json:"pay_ali_private_key" label:"支付宝开放平台-第三方应用-接口加签-应用私钥"`

  324. 			PayAliPublicKey  string `json:"pay_ali_public_key" label:"支付宝开放平台-第三方应用-接口加签-支付宝公钥"`

  325. 		}{

  326. 			PayAliAppId:      sysCfg[enum2.OpenAlipayAppid],

  327. 			PayAliPrivateKey: sysCfg[enum2.OpenAlipayAppPrivateKey],

  328. 			PayAliPublicKey:  sysCfg[enum2.OpenAlipayPublicKey],

  329. 		},

  330. 		OpAppId:      sysCfg[enum2.OpenAppletAppid],

  331. 		BuyerId:      user.UserId,

  332. 		TotalAmount:  total,

  333. 		OutTradeNo:   outTradeNo,

  334. 		Subject:      "购买食堂套餐",

  335. 		AppAuthToken: sysCfg[enum2.JsapiPayAppAutToken],

  336. 	})

  337. 	if err != nil {

  338. 		return

  339. 	}

  340. 

  341. 	//5、插入订单记录

  342. 	now := time.Now()

  343. 	NursingHomePackageOrd := db.NursingHomePackageOrd{}

  344. 	NursingHomePackageOrd.Set(outTradeNo)

  345. 	_, err = NursingHomePackageOrd.NursingHomePackageOrdInsertBySession(session, &model.NursingHomePackageOrd{

  346. 		EnterpriseId:     req.EnterpriseId,

  347. 		Uid:              user.Id,

  348. 		UserIdentityId:   req.UserIdentityId,

  349. 		UserIdentityName: userIdentity.Name,

  350. 		TotalPrice:       total,

  351. 		Kind:             req.Kind,

  352. 		OutTradeNo:       outTradeNo,

  353. 		TradeNo:          resp.TradeNo,

  354. 		State:            enum2.NursingHomePackageOrdStateForWait,

  355. 		OrdState:         enum2.NursingHomePackageOrdOrdStateForWait,

  356. 		ReqContent:       string(utils.Serialize(req)),

  357. 		WithDayData:      string(utils.Serialize(data)),

  358. 		CreateAt:         now.Format("2006-01-02 15:04:05"),

  359. 		UpdateAt:         now.Format("2006-01-02 15:04:05"),

  360. 	})

  361. 	if err != nil {

  362. 		_ = session.Rollback()

  363. 		return

  364. 	}

  365. 	session.Commit()

  366. 	tradeNo = resp.TradeNo

  367. 	return

  368. }

  369. 

  370. func DealCentralKitchenForSchoolOrderCallBack(outTradeNo, tradeStatus string) (state int, err error) {

  371. 	centralKitchenForSchoolPackageOrd := db.CentralKitchenForSchoolPackageOrd{}

  372. 	centralKitchenForSchoolPackageOrd.Set(outTradeNo)

  373. 	ord, err := centralKitchenForSchoolPackageOrd.GetCentralKitchenForSchoolPackageOrd()

  374. 	if err != nil {

  375. 		return

  376. 	}

  377. 	if ord == nil {

  378. 		err = errors.New("未查询到对应订单记录")

  379. 		return

  380. 	}

  381. 

  382. 	if ord.State == enum2.CentralKitchenForSchoolPackageOrdStateForWait {

  383. 		if tradeStatus == "TRADE_CLOSED" {

  384. 			ord.State = enum2.CentralKitchenForSchoolPackageOrdStateForFail

  385. 		}

  386. 

  387. 		if tradeStatus == "TRADE_SUCCESS" {

  388. 			ord.State = enum2.CentralKitchenForSchoolPackageOrdStateForSuccess

  389. 			ord.OrdState = enum2.CentralKitchenForSchoolPackageOrdOrdStateForSuccess

  390. 

  391. 			//TODO::将预留数据插入到 `central_kitchen_for_school_user_with_day`

  392. 			var data []*model.CentralKitchenForSchoolUserWithDay

  393. 			err = json.Unmarshal([]byte(ord.WithDayData), &data)

  394. 			if err != nil {

  395. 				return

  396. 			}

  397. 

  398. 			var hasMonths = map[string]map[string]interface{}{}

  399. 			var hasKinds = map[string]map[string]string{}

  400. 			var hasTotalPrice = map[string]map[string]float64{}

  401. 			for _, v := range data {

  402. 				date, _ := time.ParseInLocation("2006-01-02", v.Date, time.Local)

  403. 				if hasMonths[utils.TimeParseStd(v.Date).Month().String()] == nil {

  404. 					hasMonths[utils.TimeParseStd(v.Date).Month().String()] = make(map[string]interface{})

  405. 					hasMonths[utils.TimeParseStd(v.Date).Month().String()]["meal_time_start"] = date.Format("2006-01-02")

  406. 					hasMonths[utils.TimeParseStd(v.Date).Month().String()]["meal_time_end"] = date.Format("2006-01-02")

  407. 				} else {

  408. 					startTime, _ := time.ParseInLocation("2006-01-02", utils.AnyToString(hasMonths[utils.TimeParseStd(v.Date).Month().String()]["meal_time_start"]), time.Local)

  409. 					if startTime.After(date) {

  410. 						hasMonths[utils.TimeParseStd(v.Date).Month().String()]["meal_time_start"] = date.Format("2006-01-02")

  411. 					}

  412. 

  413. 					endTime, _ := time.ParseInLocation("2006-01-02", utils.AnyToString(hasMonths[utils.TimeParseStd(v.Date).Month().String()]["meal_time_end"]), time.Local)

  414. 					if endTime.Before(date) {

  415. 						hasMonths[utils.TimeParseStd(v.Date).Month().String()]["meal_time_end"] = date.Format("2006-01-02")

  416. 					}

  417. 				}

  418. 				if hasTotalPrice[utils.TimeParseStd(v.Date).Month().String()] == nil {

  419. 					hasTotalPrice[utils.TimeParseStd(v.Date).Month().String()] = make(map[string]float64)

  420. 				}

  421. 				if hasKinds[utils.TimeParseStd(v.Date).Month().String()] == nil {

  422. 					hasKinds[utils.TimeParseStd(v.Date).Month().String()] = make(map[string]string)

  423. 				}

  424. 

  425. 				hasMonths[utils.TimeParseStd(v.Date).Month().String()]["month"] = int(utils.TimeParseStd(v.Date).Month())

  426. 				hasKinds[utils.TimeParseStd(v.Date).Month().String()][utils.IntToStr(v.Kind)] = utils.IntToStr(v.Kind)

  427. 				hasTotalPrice[utils.TimeParseStd(v.Date).Month().String()][utils.IntToStr(v.Kind)] += utils.StrToFloat64(v.Amount)

  428. 				v.OrdNo = outTradeNo

  429. 			}

  430. 

  431. 			centralKitchenForSchoolUserWithDayDb := db.CentralKitchenForSchoolUserWithDayDb{}

  432. 			centralKitchenForSchoolUserWithDayDb.Set(0)

  433. 			_, err = centralKitchenForSchoolUserWithDayDb.BatchAddCentralKitchenForSchoolUserWithDays(data)

  434. 			if err != nil {

  435. 				return

  436. 			}

  437. 

  438. 			//TODO::插入数据至 `central_kitchen_for_school_package_ord_for_reserve`

  439. 			centralKitchenForSchoolPackageOrdForReserve := db.CentralKitchenForSchoolPackageOrdForReserve{}

  440. 			centralKitchenForSchoolPackageOrdForReserve.Set(outTradeNo)

  441. 			for k, v := range hasMonths {

  442. 				for _, v1 := range hasKinds[k] {

  443. 					_, err = centralKitchenForSchoolPackageOrdForReserve.CentralKitchenForSchoolPackageOrdForReserveInsert(&model.CentralKitchenForSchoolPackageOrdForReserve{

  444. 						EnterpriseId:     ord.EnterpriseId,

  445. 						Uid:              ord.Uid,

  446. 						UserIdentityName: ord.UserIdentityName,

  447. 						UserIdentityId:   ord.UserIdentityId,

  448. 						Kind:             utils.StrToInt(v1),

  449. 						OutTradeNo:       ord.OutTradeNo,

  450. 						ReserveMonth:     utils.AnyToString(v["month"]),

  451. 						MealTimeStart:    utils.AnyToString(v["meal_time_start"]),

  452. 						MealTimeEnd:      utils.AnyToString(v["meal_time_end"]),

  453. 						TotalPrice:       utils.Float64ToStr(hasTotalPrice[k][v1]),

  454. 						CreateAt:         time.Now().Format("2006-01-02 15:04:05"),

  455. 						UpdateAt:         time.Now().Format("2006-01-02 15:04:05"),

  456. 					})

  457. 					if err != nil {

  458. 						return

  459. 					}

  460. 				}

  461. 			}

  462. 		}

  463. 		_, err = centralKitchenForSchoolPackageOrd.CentralKitchenForSchoolPackageOrdUpdate(ord, "state", "ord_state")

  464. 		if err != nil {

  465. 			return

  466. 		}

  467. 	}

  468. 	state = ord.State

  469. 	return

  470. }

  471. 

  472. func CheckAllCallbackParams(c *gin.Context) interface{} {

  473. 	body, _ := ioutil.ReadAll(c.Request.Body)

  474. 	utils.FilePutContents("CheckAllCallbackParams", utils.SerializeStr(string(body)))

  475. 	dataAlipay, _ := GetAlipayCallbackParams(body)

  476. 	if dataAlipay != nil {

  477. 		return dataAlipay

  478. 	}

  479. 	return nil

  480. }

  481. 

  482. // GetAlipayCallbackParams 支付宝参数解析

  483. func GetAlipayCallbackParams(body []byte) (*md.AliPayCallback, error) {

  484. 	decodeArgs, err := url.QueryUnescape(string(body))

  485. 	if err != nil {

  486. 		_ = logx.Warn(err)

  487. 		return nil, logx.Warn("回调参数解码错误")

  488. 	}

  489. 	data, err := url.ParseQuery(decodeArgs)

  490. 	if err != nil {

  491. 		return nil, err

  492. 	}

  493. 	dataMap := make(map[string]interface{})

  494. 	for k := range data {

  495. 		dataMap[k] = data.Get(k)

  496. 	}

  497. 	callbackStr := utils.Serialize(dataMap)

  498. 	fmt.Println("支付宝回调数据", string(callbackStr))

  499. 	var args md.AliPayCallback

  500. 	if err := json.Unmarshal(callbackStr, &args); err != nil {

  501. 		return nil, logx.Warn(err)

  502. 	}

  503. 	return &args, nil

  504. }