SmartCanteen
/
smart_canteen
2
0
派生 0
代码 工单 0 合并请求 0 版本发布 0 百科 动态
智慧食堂
您最多选择25个主题 主题必须以字母或数字开头，可以包含连字符 (-)，并且长度不得超过35个字符
301 提交
5 分支
8.2 MiB
 
 
目录树: d3f648e02d
分支列表 标签列表
${ item.name }
创建分支 ${ searchTerm }
从 'd3f648e02d'
${ noResults }
smart_canteen/app/customer/svc/svc_pay.go

529 行
17 KiB
原始文件 Blame 文件历史 

  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. 	jsapi2 "github.com/wechatpay-apiv3/wechatpay-go/services/payments/jsapi"

  19. 	utils2 "github.com/wechatpay-apiv3/wechatpay-go/utils"

  20. 	"io/ioutil"

  21. 	"math"

  22. 	"net/url"

  23. 	"strconv"

  24. 	"time"

  25. )

  26. 

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

  28. 	user := GetUser(c)

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

  30. 	defer session.Close()

  31. 	session.Begin()

  32. 	if err != nil {

  33. 		_ = session.Rollback()

  34. 		return

  35. 	}

  36. 

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

  38. 	isTeacher := false

  39. 	userIdentityDb := db.UserIdentityDb{}

  40. 	userIdentityDb.Set(0)

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

  42. 	if err != nil {

  43. 		return

  44. 	}

  45. 	if userIdentity == nil {

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

  47. 		return

  48. 	}

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

  50. 		isTeacher = true

  51. 	}

  52. 

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

  54. 	var totalPrice float64

  55. 	var data []*model.CentralKitchenForSchoolUserWithDay

  56. 	if req.Kind == 1 {

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

  58. 		if err != nil {

  59. 			return

  60. 		}

  61. 	}

  62. 	if req.Kind == 2 {

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

  64. 		if err != nil {

  65. 			return

  66. 		}

  67. 	}

  68. 	if req.Kind == 3 {

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

  70. 		if err != nil {

  71. 			return

  72. 		}

  73. 	}

  74. 	if req.Kind == 4 {

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

  76. 		if err != nil {

  77. 			return

  78. 		}

  79. 	}

  80. 	total = utils.Float64ToStr(totalPrice)

  81. 

  82. 	//3、生成订单号

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

  84. 

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

  86. 	sysCfgDb := db.SysCfgDb{}

  87. 	sysCfgDb.Set()

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

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

  90. 		Config: struct {

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

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

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

  94. 		}{

  95. 			PayAliAppId:      sysCfg[enum2.OpenAlipayAppid],

  96. 			PayAliPrivateKey: sysCfg[enum2.OpenAlipayAppPrivateKey],

  97. 			PayAliPublicKey:  sysCfg[enum2.OpenAlipayPublicKey],

  98. 		},

  99. 		OpAppId:      sysCfg[enum2.OpenAppletAppid],

  100. 		BuyerId:      user.UserId,

  101. 		TotalAmount:  total,

  102. 		OutTradeNo:   outTradeNo,

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

  104. 		AppAuthToken: sysCfg[enum2.JsapiPayAppAutToken],

  105. 		NotifyUrl:    sysCfg[enum2.JsapiPayNotifyUrl],

  106. 	})

  107. 	if err != nil {

  108. 		return

  109. 	}

  110. 

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

  112. 	now := time.Now()

  113. 	centralKitchenForSchoolPackageOrd := db.CentralKitchenForSchoolPackageOrd{}

  114. 	centralKitchenForSchoolPackageOrd.Set(outTradeNo)

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

  116. 		EnterpriseId:     req.EnterpriseId,

  117. 		Uid:              user.Id,

  118. 		UserIdentityId:   req.UserIdentityId,

  119. 		UserIdentityName: userIdentity.Name,

  120. 		TotalPrice:       total,

  121. 		Kind:             req.Kind,

  122. 		OutTradeNo:       outTradeNo,

  123. 		TradeNo:          resp.TradeNo,

  124. 		State:            enum2.CentralKitchenForSchoolPackageOrdStateForWait,

  125. 		OrdState:         enum2.CentralKitchenForSchoolPackageOrdOrdStateForWait,

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

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

  128. 		PayWay:           enum.PayWayForAli,

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

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

  131. 	})

  132. 	if err != nil {

  133. 		_ = session.Rollback()

  134. 		return

  135. 	}

  136. 	session.Commit()

  137. 	tradeNo = resp.TradeNo

  138. 	return

  139. }

  140. 

  141. func BuyPackageForWx(c *gin.Context, req md.BuyPackageReq) (outTradeNo, total string, resp *jsapi2.PrepayWithRequestPaymentResponse, err error) {

  142. 	user := GetUser(c)

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

  144. 	defer session.Close()

  145. 	session.Begin()

  146. 	if err != nil {

  147. 		_ = session.Rollback()

  148. 		return

  149. 	}

  150. 

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

  152. 	isTeacher := false

  153. 	userIdentityDb := db.UserIdentityDb{}

  154. 	userIdentityDb.Set(0)

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

  156. 	if err != nil {

  157. 		return

  158. 	}

  159. 	if userIdentity == nil {

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

  161. 		return

  162. 	}

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

  164. 		isTeacher = true

  165. 	}

  166. 

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

  168. 	var totalPrice float64

  169. 	var data []*model.CentralKitchenForSchoolUserWithDay

  170. 	if req.Kind == 1 {

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

  172. 		if err != nil {

  173. 			return

  174. 		}

  175. 	}

  176. 	if req.Kind == 2 {

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

  178. 		if err != nil {

  179. 			return

  180. 		}

  181. 	}

  182. 	if req.Kind == 3 {

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

  184. 		if err != nil {

  185. 			return

  186. 		}

  187. 	}

  188. 	if req.Kind == 4 {

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

  190. 		if err != nil {

  191. 			return

  192. 		}

  193. 	}

  194. 	total = utils.Float64ToStr(totalPrice)

  195. 

  196. 	//3、生成订单号

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

  198. 

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

  200. 	sysCfgDb := db.SysCfgDb{}

  201. 	sysCfgDb.Set()

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

  203. 	if err != nil {

  204. 		return

  205. 	}

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

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

  208. 	fmt.Println(int64(math.Round(totalPrice * 100)))

  209. 	result, _, err := wxSvc.Prepay(c,

  210. 		jsapi.PrepayRequest{

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

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

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

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

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

  216. 			OutTradeNo:  core.String(outTradeNo),

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

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

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

  220. 			Amount: &jsapi.Amount{

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

  222. 				Total:    core.Int64(int64(math.Round(totalPrice * 100))),

  223. 			},

  224. 			Payer: &jsapi.Payer{

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

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

  227. 			},

  228. 		},

  229. 	)

  230. 

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

  232. 	if err != nil {

  233. 		_ = session.Rollback()

  234. 		return

  235. 	}

  236. 

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

  238. 	now := time.Now()

  239. 	centralKitchenForSchoolPackageOrd := db.CentralKitchenForSchoolPackageOrd{}

  240. 	centralKitchenForSchoolPackageOrd.Set(outTradeNo)

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

  242. 		EnterpriseId:     req.EnterpriseId,

  243. 		Uid:              user.Id,

  244. 		UserIdentityId:   req.UserIdentityId,

  245. 		UserIdentityName: userIdentity.Name,

  246. 		TotalPrice:       total,

  247. 		Kind:             req.Kind,

  248. 		OutTradeNo:       outTradeNo,

  249. 		TradeNo:          "",

  250. 		State:            enum2.CentralKitchenForSchoolPackageOrdStateForWait,

  251. 		OrdState:         enum2.CentralKitchenForSchoolPackageOrdOrdStateForWait,

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

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

  254. 		PayWay:           enum.PayWayForWx,

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

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

  257. 	})

  258. 	if err != nil {

  259. 		_ = session.Rollback()

  260. 		return

  261. 	}

  262. 	session.Commit()

  263. 	//prepayId = *resp.PrepayId

  264. 	resp = new(jsapi2.PrepayWithRequestPaymentResponse)

  265. 	resp.PrepayId = result.PrepayId

  266. 	resp.SignType = core.String("RSA")

  267. 	appid := sysCfg[enum2.WxAppletAppId]

  268. 	resp.Appid = &appid

  269. 	resp.TimeStamp = core.String(strconv.FormatInt(time.Now().Unix(), 10))

  270. 	nonce, err := utils2.GenerateNonce()

  271. 	if err != nil {

  272. 		_ = session.Rollback()

  273. 		return

  274. 	}

  275. 	resp.NonceStr = core.String(nonce)

  276. 	resp.Package = core.String("prepay_id=" + *result.PrepayId)

  277. 	message := fmt.Sprintf("%s\n%s\n%s\n%s\n", *resp.Appid, *resp.TimeStamp, *resp.NonceStr, *resp.Package)

  278. 	signatureResult, err := wxSvc.Client.Sign(c, message)

  279. 	if err != nil {

  280. 		_ = session.Rollback()

  281. 		return

  282. 	}

  283. 	resp.PaySign = core.String(signatureResult.Signature)

  284. 	return

  285. }

  286. 

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

  288. 	user := GetUser(c)

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

  290. 	defer session.Close()

  291. 	session.Begin()

  292. 	if err != nil {

  293. 		_ = session.Rollback()

  294. 		return

  295. 	}

  296. 

  297. 	userIdentityDb := db.UserIdentityDb{}

  298. 	userIdentityDb.Set(0)

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

  300. 	if err != nil {

  301. 		return

  302. 	}

  303. 	if userIdentity == nil {

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

  305. 		return

  306. 	}

  307. 

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

  309. 	var totalPrice float64

  310. 	var data []*model.NursingHomeUserWithDay

  311. 	if req.Kind == 1 {

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

  313. 		if err != nil {

  314. 			return

  315. 		}

  316. 	}

  317. 	if req.Kind == 2 {

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

  319. 		if err != nil {

  320. 			return

  321. 		}

  322. 	}

  323. 	if req.Kind == 3 {

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

  325. 		if err != nil {

  326. 			return

  327. 		}

  328. 	}

  329. 	if req.Kind == 4 {

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

  331. 		if err != nil {

  332. 			return

  333. 		}

  334. 	}

  335. 	total = utils.Float64ToStr(totalPrice)

  336. 

  337. 	//3、生成订单号

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

  339. 

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

  341. 	sysCfgDb := db.SysCfgDb{}

  342. 	sysCfgDb.Set()

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

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

  345. 		Config: struct {

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

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

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

  349. 		}{

  350. 			PayAliAppId:      sysCfg[enum2.OpenAlipayAppid],

  351. 			PayAliPrivateKey: sysCfg[enum2.OpenAlipayAppPrivateKey],

  352. 			PayAliPublicKey:  sysCfg[enum2.OpenAlipayPublicKey],

  353. 		},

  354. 		OpAppId:      sysCfg[enum2.OpenAppletAppid],

  355. 		BuyerId:      user.UserId,

  356. 		TotalAmount:  total,

  357. 		OutTradeNo:   outTradeNo,

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

  359. 		AppAuthToken: sysCfg[enum2.JsapiPayAppAutToken],

  360. 	})

  361. 	if err != nil {

  362. 		return

  363. 	}

  364. 

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

  366. 	now := time.Now()

  367. 	NursingHomePackageOrd := db.NursingHomePackageOrd{}

  368. 	NursingHomePackageOrd.Set(outTradeNo)

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

  370. 		EnterpriseId:     req.EnterpriseId,

  371. 		Uid:              user.Id,

  372. 		UserIdentityId:   req.UserIdentityId,

  373. 		UserIdentityName: userIdentity.Name,

  374. 		TotalPrice:       total,

  375. 		Kind:             req.Kind,

  376. 		OutTradeNo:       outTradeNo,

  377. 		TradeNo:          resp.TradeNo,

  378. 		State:            enum2.NursingHomePackageOrdStateForWait,

  379. 		OrdState:         enum2.NursingHomePackageOrdOrdStateForWait,

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

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

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

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

  384. 	})

  385. 	if err != nil {

  386. 		_ = session.Rollback()

  387. 		return

  388. 	}

  389. 	session.Commit()

  390. 	tradeNo = resp.TradeNo

  391. 	return

  392. }

  393. 

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

  395. 	centralKitchenForSchoolPackageOrd := db.CentralKitchenForSchoolPackageOrd{}

  396. 	centralKitchenForSchoolPackageOrd.Set(outTradeNo)

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

  398. 	if err != nil {

  399. 		return

  400. 	}

  401. 	if ord == nil {

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

  403. 		return

  404. 	}

  405. 

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

  407. 		if tradeStatus == "TRADE_CLOSED" {

  408. 			ord.State = enum2.CentralKitchenForSchoolPackageOrdStateForFail

  409. 		}

  410. 

  411. 		if tradeStatus == "TRADE_SUCCESS" {

  412. 			ord.State = enum2.CentralKitchenForSchoolPackageOrdStateForSuccess

  413. 			ord.OrdState = enum2.CentralKitchenForSchoolPackageOrdOrdStateForSuccess

  414. 

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

  416. 			var data []*model.CentralKitchenForSchoolUserWithDay

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

  418. 			if err != nil {

  419. 				return

  420. 			}

  421. 

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

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

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

  425. 			for _, v := range data {

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

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

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

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

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

  431. 				} else {

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

  433. 					if startTime.After(date) {

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

  435. 					}

  436. 

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

  438. 					if endTime.Before(date) {

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

  440. 					}

  441. 				}

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

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

  444. 				}

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

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

  447. 				}

  448. 

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

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

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

  452. 				v.OrdNo = outTradeNo

  453. 			}

  454. 

  455. 			centralKitchenForSchoolUserWithDayDb := db.CentralKitchenForSchoolUserWithDayDb{}

  456. 			centralKitchenForSchoolUserWithDayDb.Set(0)

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

  458. 			if err != nil {

  459. 				return

  460. 			}

  461. 

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

  463. 			centralKitchenForSchoolPackageOrdForReserve := db.CentralKitchenForSchoolPackageOrdForReserve{}

  464. 			centralKitchenForSchoolPackageOrdForReserve.Set(outTradeNo)

  465. 			for k, v := range hasMonths {

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

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

  468. 						EnterpriseId:     ord.EnterpriseId,

  469. 						Uid:              ord.Uid,

  470. 						UserIdentityName: ord.UserIdentityName,

  471. 						UserIdentityId:   ord.UserIdentityId,

  472. 						Kind:             utils.StrToInt(v1),

  473. 						OutTradeNo:       ord.OutTradeNo,

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

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

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

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

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

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

  480. 					})

  481. 					if err != nil {

  482. 						return

  483. 					}

  484. 				}

  485. 			}

  486. 		}

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

  488. 		if err != nil {

  489. 			return

  490. 		}

  491. 	}

  492. 	state = ord.State

  493. 	return

  494. }

  495. 

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

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

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

  499. 	dataAlipay, _ := GetAlipayCallbackParams(body)

  500. 	if dataAlipay != nil {

  501. 		return dataAlipay

  502. 	}

  503. 	return nil

  504. }

  505. 

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

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

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

  509. 	if err != nil {

  510. 		_ = logx.Warn(err)

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

  512. 	}

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

  514. 	if err != nil {

  515. 		return nil, err

  516. 	}

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

  518. 	for k := range data {

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

  520. 	}

  521. 	callbackStr := utils.Serialize(dataMap)

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

  523. 	var args md.AliPayCallback

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

  525. 		return nil, logx.Warn(err)

  526. 	}

  527. 	return &args, nil

  528. }