SmartCanteen
/
smart_canteen
2
0
Bifurcation 0
Code Tickets 0 Demandes d'ajout 0 Versions 0 Wiki Activité
智慧食堂
Vous ne pouvez pas sélectionner plus de 25 sujets Les noms de sujets doivent commencer par une lettre ou un nombre, peuvent contenir des tirets ('-') et peuvent comporter jusqu'à 35 caractères.
294 Révisions
5 Branches
8.2 MiB
 
 
Aborescence: cac56e5ef8
Branches Tags
${ item.name }
Créer la branche ${ searchTerm }
de 'cac56e5ef8'
${ noResults }
smart_canteen/app/customer/svc/svc_pay.go

528 lignes
17 KiB
Brut Annotations Historique 

  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. 	"net/url"

  22. 	"strconv"

  23. 	"time"

  24. )

  25. 

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

  27. 	user := GetUser(c)

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

  29. 	defer session.Close()

  30. 	session.Begin()

  31. 	if err != nil {

  32. 		_ = session.Rollback()

  33. 		return

  34. 	}

  35. 

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

  37. 	isTeacher := false

  38. 	userIdentityDb := db.UserIdentityDb{}

  39. 	userIdentityDb.Set(0)

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

  41. 	if err != nil {

  42. 		return

  43. 	}

  44. 	if userIdentity == nil {

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

  46. 		return

  47. 	}

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

  49. 		isTeacher = true

  50. 	}

  51. 

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

  53. 	var totalPrice float64

  54. 	var data []*model.CentralKitchenForSchoolUserWithDay

  55. 	if req.Kind == 1 {

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

  57. 		if err != nil {

  58. 			return

  59. 		}

  60. 	}

  61. 	if req.Kind == 2 {

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

  63. 		if err != nil {

  64. 			return

  65. 		}

  66. 	}

  67. 	if req.Kind == 3 {

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

  69. 		if err != nil {

  70. 			return

  71. 		}

  72. 	}

  73. 	if req.Kind == 4 {

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

  75. 		if err != nil {

  76. 			return

  77. 		}

  78. 	}

  79. 	total = utils.Float64ToStr(totalPrice)

  80. 

  81. 	//3、生成订单号

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

  83. 

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

  85. 	sysCfgDb := db.SysCfgDb{}

  86. 	sysCfgDb.Set()

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

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

  89. 		Config: struct {

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

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

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

  93. 		}{

  94. 			PayAliAppId:      sysCfg[enum2.OpenAlipayAppid],

  95. 			PayAliPrivateKey: sysCfg[enum2.OpenAlipayAppPrivateKey],

  96. 			PayAliPublicKey:  sysCfg[enum2.OpenAlipayPublicKey],

  97. 		},

  98. 		OpAppId:      sysCfg[enum2.OpenAppletAppid],

  99. 		BuyerId:      user.UserId,

  100. 		TotalAmount:  total,

  101. 		OutTradeNo:   outTradeNo,

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

  103. 		AppAuthToken: sysCfg[enum2.JsapiPayAppAutToken],

  104. 		NotifyUrl:    sysCfg[enum2.JsapiPayNotifyUrl],

  105. 	})

  106. 	if err != nil {

  107. 		return

  108. 	}

  109. 

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

  111. 	now := time.Now()

  112. 	centralKitchenForSchoolPackageOrd := db.CentralKitchenForSchoolPackageOrd{}

  113. 	centralKitchenForSchoolPackageOrd.Set(outTradeNo)

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

  115. 		EnterpriseId:     req.EnterpriseId,

  116. 		Uid:              user.Id,

  117. 		UserIdentityId:   req.UserIdentityId,

  118. 		UserIdentityName: userIdentity.Name,

  119. 		TotalPrice:       total,

  120. 		Kind:             req.Kind,

  121. 		OutTradeNo:       outTradeNo,

  122. 		TradeNo:          resp.TradeNo,

  123. 		State:            enum2.CentralKitchenForSchoolPackageOrdStateForWait,

  124. 		OrdState:         enum2.CentralKitchenForSchoolPackageOrdOrdStateForWait,

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

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

  127. 		PayWay:           enum.PayWayForAli,

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

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

  130. 	})

  131. 	if err != nil {

  132. 		_ = session.Rollback()

  133. 		return

  134. 	}

  135. 	session.Commit()

  136. 	tradeNo = resp.TradeNo

  137. 	return

  138. }

  139. 

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

  141. 	user := GetUser(c)

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

  143. 	defer session.Close()

  144. 	session.Begin()

  145. 	if err != nil {

  146. 		_ = session.Rollback()

  147. 		return

  148. 	}

  149. 

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

  151. 	isTeacher := false

  152. 	userIdentityDb := db.UserIdentityDb{}

  153. 	userIdentityDb.Set(0)

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

  155. 	if err != nil {

  156. 		return

  157. 	}

  158. 	if userIdentity == nil {

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

  160. 		return

  161. 	}

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

  163. 		isTeacher = true

  164. 	}

  165. 

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

  167. 	var totalPrice float64

  168. 	var data []*model.CentralKitchenForSchoolUserWithDay

  169. 	if req.Kind == 1 {

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

  171. 		if err != nil {

  172. 			return

  173. 		}

  174. 	}

  175. 	if req.Kind == 2 {

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

  177. 		if err != nil {

  178. 			return

  179. 		}

  180. 	}

  181. 	if req.Kind == 3 {

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

  183. 		if err != nil {

  184. 			return

  185. 		}

  186. 	}

  187. 	if req.Kind == 4 {

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

  189. 		if err != nil {

  190. 			return

  191. 		}

  192. 	}

  193. 	total = utils.Float64ToStr(totalPrice)

  194. 

  195. 	//3、生成订单号

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

  197. 

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

  199. 	sysCfgDb := db.SysCfgDb{}

  200. 	sysCfgDb.Set()

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

  202. 	if err != nil {

  203. 		return

  204. 	}

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

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

  207. 

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

  209. 		jsapi.PrepayRequest{

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

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

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

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

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

  215. 			OutTradeNo:  core.String(outTradeNo),

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

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

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

  219. 			Amount: &jsapi.Amount{

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

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

  222. 			},

  223. 			Payer: &jsapi.Payer{

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

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

  226. 			},

  227. 		},

  228. 	)

  229. 

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

  231. 	if err != nil {

  232. 		_ = session.Rollback()

  233. 		return

  234. 	}

  235. 

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

  237. 	now := time.Now()

  238. 	centralKitchenForSchoolPackageOrd := db.CentralKitchenForSchoolPackageOrd{}

  239. 	centralKitchenForSchoolPackageOrd.Set(outTradeNo)

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

  241. 		EnterpriseId:     req.EnterpriseId,

  242. 		Uid:              user.Id,

  243. 		UserIdentityId:   req.UserIdentityId,

  244. 		UserIdentityName: userIdentity.Name,

  245. 		TotalPrice:       total,

  246. 		Kind:             req.Kind,

  247. 		OutTradeNo:       outTradeNo,

  248. 		TradeNo:          "",

  249. 		State:            enum2.CentralKitchenForSchoolPackageOrdStateForWait,

  250. 		OrdState:         enum2.CentralKitchenForSchoolPackageOrdOrdStateForWait,

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

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

  253. 		PayWay:           enum.PayWayForWx,

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

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

  256. 	})

  257. 	if err != nil {

  258. 		_ = session.Rollback()

  259. 		return

  260. 	}

  261. 	session.Commit()

  262. 	//prepayId = *resp.PrepayId

  263. 	resp = new(jsapi2.PrepayWithRequestPaymentResponse)

  264. 	resp.PrepayId = result.PrepayId

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

  266. 	appid := sysCfg[enum2.WxSpAppId]

  267. 	resp.Appid = &appid

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

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

  270. 	if err != nil {

  271. 		_ = session.Rollback()

  272. 		return

  273. 	}

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

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

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

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

  278. 	if err != nil {

  279. 		_ = session.Rollback()

  280. 		return

  281. 	}

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

  283. 	return

  284. }

  285. 

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

  287. 	user := GetUser(c)

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

  289. 	defer session.Close()

  290. 	session.Begin()

  291. 	if err != nil {

  292. 		_ = session.Rollback()

  293. 		return

  294. 	}

  295. 

  296. 	userIdentityDb := db.UserIdentityDb{}

  297. 	userIdentityDb.Set(0)

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

  299. 	if err != nil {

  300. 		return

  301. 	}

  302. 	if userIdentity == nil {

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

  304. 		return

  305. 	}

  306. 

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

  308. 	var totalPrice float64

  309. 	var data []*model.NursingHomeUserWithDay

  310. 	if req.Kind == 1 {

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

  312. 		if err != nil {

  313. 			return

  314. 		}

  315. 	}

  316. 	if req.Kind == 2 {

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

  318. 		if err != nil {

  319. 			return

  320. 		}

  321. 	}

  322. 	if req.Kind == 3 {

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

  324. 		if err != nil {

  325. 			return

  326. 		}

  327. 	}

  328. 	if req.Kind == 4 {

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

  330. 		if err != nil {

  331. 			return

  332. 		}

  333. 	}

  334. 	total = utils.Float64ToStr(totalPrice)

  335. 

  336. 	//3、生成订单号

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

  338. 

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

  340. 	sysCfgDb := db.SysCfgDb{}

  341. 	sysCfgDb.Set()

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

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

  344. 		Config: struct {

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

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

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

  348. 		}{

  349. 			PayAliAppId:      sysCfg[enum2.OpenAlipayAppid],

  350. 			PayAliPrivateKey: sysCfg[enum2.OpenAlipayAppPrivateKey],

  351. 			PayAliPublicKey:  sysCfg[enum2.OpenAlipayPublicKey],

  352. 		},

  353. 		OpAppId:      sysCfg[enum2.OpenAppletAppid],

  354. 		BuyerId:      user.UserId,

  355. 		TotalAmount:  total,

  356. 		OutTradeNo:   outTradeNo,

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

  358. 		AppAuthToken: sysCfg[enum2.JsapiPayAppAutToken],

  359. 	})

  360. 	if err != nil {

  361. 		return

  362. 	}

  363. 

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

  365. 	now := time.Now()

  366. 	NursingHomePackageOrd := db.NursingHomePackageOrd{}

  367. 	NursingHomePackageOrd.Set(outTradeNo)

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

  369. 		EnterpriseId:     req.EnterpriseId,

  370. 		Uid:              user.Id,

  371. 		UserIdentityId:   req.UserIdentityId,

  372. 		UserIdentityName: userIdentity.Name,

  373. 		TotalPrice:       total,

  374. 		Kind:             req.Kind,

  375. 		OutTradeNo:       outTradeNo,

  376. 		TradeNo:          resp.TradeNo,

  377. 		State:            enum2.NursingHomePackageOrdStateForWait,

  378. 		OrdState:         enum2.NursingHomePackageOrdOrdStateForWait,

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

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

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

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

  383. 	})

  384. 	if err != nil {

  385. 		_ = session.Rollback()

  386. 		return

  387. 	}

  388. 	session.Commit()

  389. 	tradeNo = resp.TradeNo

  390. 	return

  391. }

  392. 

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

  394. 	centralKitchenForSchoolPackageOrd := db.CentralKitchenForSchoolPackageOrd{}

  395. 	centralKitchenForSchoolPackageOrd.Set(outTradeNo)

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

  397. 	if err != nil {

  398. 		return

  399. 	}

  400. 	if ord == nil {

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

  402. 		return

  403. 	}

  404. 

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

  406. 		if tradeStatus == "TRADE_CLOSED" {

  407. 			ord.State = enum2.CentralKitchenForSchoolPackageOrdStateForFail

  408. 		}

  409. 

  410. 		if tradeStatus == "TRADE_SUCCESS" {

  411. 			ord.State = enum2.CentralKitchenForSchoolPackageOrdStateForSuccess

  412. 			ord.OrdState = enum2.CentralKitchenForSchoolPackageOrdOrdStateForSuccess

  413. 

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

  415. 			var data []*model.CentralKitchenForSchoolUserWithDay

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

  417. 			if err != nil {

  418. 				return

  419. 			}

  420. 

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

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

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

  424. 			for _, v := range data {

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

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

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

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

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

  430. 				} else {

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

  432. 					if startTime.After(date) {

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

  434. 					}

  435. 

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

  437. 					if endTime.Before(date) {

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

  439. 					}

  440. 				}

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

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

  443. 				}

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

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

  446. 				}

  447. 

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

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

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

  451. 				v.OrdNo = outTradeNo

  452. 			}

  453. 

  454. 			centralKitchenForSchoolUserWithDayDb := db.CentralKitchenForSchoolUserWithDayDb{}

  455. 			centralKitchenForSchoolUserWithDayDb.Set(0)

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

  457. 			if err != nil {

  458. 				return

  459. 			}

  460. 

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

  462. 			centralKitchenForSchoolPackageOrdForReserve := db.CentralKitchenForSchoolPackageOrdForReserve{}

  463. 			centralKitchenForSchoolPackageOrdForReserve.Set(outTradeNo)

  464. 			for k, v := range hasMonths {

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

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

  467. 						EnterpriseId:     ord.EnterpriseId,

  468. 						Uid:              ord.Uid,

  469. 						UserIdentityName: ord.UserIdentityName,

  470. 						UserIdentityId:   ord.UserIdentityId,

  471. 						Kind:             utils.StrToInt(v1),

  472. 						OutTradeNo:       ord.OutTradeNo,

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

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

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

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

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

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

  479. 					})

  480. 					if err != nil {

  481. 						return

  482. 					}

  483. 				}

  484. 			}

  485. 		}

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

  487. 		if err != nil {

  488. 			return

  489. 		}

  490. 	}

  491. 	state = ord.State

  492. 	return

  493. }

  494. 

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

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

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

  498. 	dataAlipay, _ := GetAlipayCallbackParams(body)

  499. 	if dataAlipay != nil {

  500. 		return dataAlipay

  501. 	}

  502. 	return nil

  503. }

  504. 

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

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

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

  508. 	if err != nil {

  509. 		_ = logx.Warn(err)

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

  511. 	}

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

  513. 	if err != nil {

  514. 		return nil, err

  515. 	}

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

  517. 	for k := range data {

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

  519. 	}

  520. 	callbackStr := utils.Serialize(dataMap)

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

  522. 	var args md.AliPayCallback

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

  524. 		return nil, logx.Warn(err)

  525. 	}

  526. 	return &args, nil

  527. }