SmartCanteen
/
smart_canteen
2
0
Fork 0
Code Issues 0 Pull Requests 0 Releases 0 Wiki Activity
智慧食堂
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.
20 Commits
5 Branches
8.2 MiB
 
 
Tree: cccc85e7a5
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'cccc85e7a5'
${ noResults }
smart_canteen/app/customer/svc/svc_curl_smart_pay.go

456 lines
14 KiB
Raw Blame History 

  1. package svc

  2. 

  3. import (

  4. 	"applet/app/cfg"

  5. 	"applet/app/customer/md"

  6. 	"applet/app/db"

  7. 	"applet/app/db/model"

  8. 	"applet/app/utils"

  9. 	"encoding/json"

  10. 	"errors"

  11. 	"time"

  12. )

  13. 

  14. func AesDecrypt(args md.CurlAesDecrypt) (error, interface{}) {

  15. 	url := cfg.SmartCanteenPay + "/alipay/decrypt/index"

  16. 	utils.FilePutContents("AesDecrypt", utils.SerializeStr(map[string]interface{}{

  17. 		"data": args,

  18. 	}))

  19. 	bytes, err := utils.CurlPost(url, utils.Serialize(args), nil)

  20. 	if err != nil {

  21. 		return err, nil

  22. 	}

  23. 	var result struct {

  24. 		Code int         `json:"code"`

  25. 		Msg  string      `json:"msg"`

  26. 		Data interface{} `json:"data"`

  27. 	}

  28. 	utils.FilePutContents("AesDecrypt", utils.SerializeStr(result))

  29. 	err = json.Unmarshal(bytes, &result)

  30. 	if err != nil {

  31. 		return err, nil

  32. 	}

  33. 	if result.Code != 0 {

  34. 		if result.Msg != "" {

  35. 			return errors.New(result.Msg), nil

  36. 		}

  37. 		return errors.New("请求智慧餐厅支付 异常/失败"), nil

  38. 	}

  39. 	return nil, result.Data

  40. }

  41. 

  42. func SystemOauthToken(args md.SystemOauthTokenReq) (error, interface{}) {

  43. 	url := cfg.SmartCanteenPay + "/alipay/systemOauthToken/index"

  44. 	utils.FilePutContents("SystemOauthToken", utils.SerializeStr(map[string]interface{}{

  45. 		"data": args,

  46. 	}))

  47. 	bytes, err := utils.CurlPost(url, utils.Serialize(args), nil)

  48. 	if err != nil {

  49. 		return err, nil

  50. 	}

  51. 	var result struct {

  52. 		Code int         `json:"code"`

  53. 		Msg  string      `json:"msg"`

  54. 		Data interface{} `json:"data"`

  55. 	}

  56. 	utils.FilePutContents("SystemOauthToken", utils.SerializeStr(result))

  57. 	err = json.Unmarshal(bytes, &result)

  58. 	if err != nil {

  59. 		return err, nil

  60. 	}

  61. 	if result.Code != 0 {

  62. 		if result.Msg != "" {

  63. 			return errors.New(result.Msg), nil

  64. 		}

  65. 		return errors.New("请求智慧餐厅支付 异常/失败"), nil

  66. 	}

  67. 	return nil, result.Data

  68. }

  69. 

  70. func CurlAlipayTradeCreate(args md.CurlAlipayTradeCreateReq) (err error, resp md.CurlAlipayTradeCreateResp) {

  71. 	url := cfg.SmartCanteenPay + "/alipay/pay/tradeCreate"

  72. 	utils.FilePutContents("CurlAlipayTradeCreate", utils.SerializeStr(map[string]interface{}{

  73. 		"args": args,

  74. 	}))

  75. 	bytes, err := utils.CurlPost(url, utils.Serialize(args), nil)

  76. 	if err != nil {

  77. 		return

  78. 	}

  79. 	var result struct {

  80. 		Code int         `json:"code"`

  81. 		Msg  string      `json:"msg"`

  82. 		Data interface{} `json:"data"`

  83. 	}

  84. 	utils.FilePutContents("CurlAlipayTradeCreate", utils.SerializeStr(result))

  85. 	err = json.Unmarshal(bytes, &result)

  86. 	if err != nil {

  87. 		return

  88. 	}

  89. 	if result.Code != 0 {

  90. 		if result.Msg != "" {

  91. 			err = errors.New(result.Msg)

  92. 			return

  93. 		}

  94. 		err = errors.New("请求智慧餐厅支付 异常/失败")

  95. 		return

  96. 	}

  97. 	err = json.Unmarshal(utils.Serialize(result.Data), &resp)

  98. 	if err != nil {

  99. 		return

  100. 	}

  101. 	return

  102. }

  103. 

  104. func CurlAlipayTradeQuery(args md.CurlAlipayTradeQueryReq) (err error, resp md.CurlAlipayTradeQueryResp) {

  105. 	url := cfg.SmartCanteenPay + "/alipay/pay/tradeCommonQuery"

  106. 	utils.FilePutContents("CurlAlipayTradeQuery", utils.SerializeStr(map[string]interface{}{

  107. 		"args": args,

  108. 	}))

  109. 	bytes, err := utils.CurlPost(url, utils.Serialize(args), nil)

  110. 	if err != nil {

  111. 		return

  112. 	}

  113. 	var result struct {

  114. 		Code int         `json:"code"`

  115. 		Msg  string      `json:"msg"`

  116. 		Data interface{} `json:"data"`

  117. 	}

  118. 	utils.FilePutContents("CurlAlipayTradeQuery", utils.SerializeStr(result))

  119. 	err = json.Unmarshal(bytes, &result)

  120. 	if err != nil {

  121. 		return

  122. 	}

  123. 	if result.Code != 0 {

  124. 		if result.Msg != "" {

  125. 			err = errors.New(result.Msg)

  126. 			return

  127. 		}

  128. 		err = errors.New("请求智慧餐厅支付 异常/失败")

  129. 		return

  130. 	}

  131. 	err = json.Unmarshal(utils.Serialize(result.Data), &resp)

  132. 	if err != nil {

  133. 		return

  134. 	}

  135. 	return

  136. }

  137. 

  138. func CurlAlipayTradeRefund(args md.CurlAlipayTradeRefundReq) (err error, resp interface{}) {

  139. 	url := cfg.SmartCanteenPay + "/alipay/pay/tradeRefund"

  140. 	utils.FilePutContents("CurlAlipayTradeRefund", utils.SerializeStr(map[string]interface{}{

  141. 		"args": args,

  142. 	}))

  143. 	bytes, err := utils.CurlPost(url, utils.Serialize(args), nil)

  144. 	if err != nil {

  145. 		return

  146. 	}

  147. 	var result struct {

  148. 		Code int         `json:"code"`

  149. 		Msg  string      `json:"msg"`

  150. 		Data interface{} `json:"data"`

  151. 	}

  152. 	utils.FilePutContents("CurlAlipayTradeRefund", utils.SerializeStr(result))

  153. 	err = json.Unmarshal(bytes, &result)

  154. 	if err != nil {

  155. 		return

  156. 	}

  157. 	if result.Code != 0 {

  158. 		if result.Msg != "" {

  159. 			err = errors.New(result.Msg)

  160. 			return

  161. 		}

  162. 		err = errors.New("请求智慧餐厅支付 异常/失败")

  163. 		return

  164. 	}

  165. 	return nil, result.Data

  166. }

  167. 

  168. func CurlEducateSceneTokenQuery(args md.CurlEducateSceneTokenReq, userIdentityId int, userToken string) (err error, resp interface{}) {

  169. 	utils.FilePutContents("CurlEducateSceneTokenQuery", utils.SerializeStr(map[string]interface{}{

  170. 		"args": args,

  171. 	}))

  172. 

  173. 	if userToken == "" {

  174. 		//1、TODO::生成用户信息token(使用 alipay.commerce.educate.scene.token.create 接口生成用户信息token)

  175. 		url := cfg.SmartCanteenPay + "/alipay/faceCollection/educateSceneTokenCreate"

  176. 		bytes, err1 := utils.CurlPost(url, utils.Serialize(map[string]interface{}{

  177. 			"config": map[string]string{

  178. 				"ali_app_id":      args.Config.AliAppId,

  179. 				"ali_private_key": args.Config.AliPrivateKey,

  180. 				"ali_public_key":  args.Config.AliPublicKey,

  181. 			},

  182. 			"cert_no":         args.CertNo,

  183. 			"school_std_code": args.SchoolStdCode,

  184. 			"student_name":    args.StudentName,

  185. 			"out_user_id":     args.OutUserId,

  186. 			"cert_type":       "1",

  187. 			"sub_code":        "SCHOOL_FACE_PASS_QUERY",

  188. 		}), nil)

  189. 		if err1 != nil {

  190. 			return

  191. 		}

  192. 		var result struct {

  193. 			Code int         `json:"code"`

  194. 			Msg  string      `json:"msg"`

  195. 			Data interface{} `json:"data"`

  196. 		}

  197. 		utils.FilePutContents("CurlEducateSceneTokenCreate", utils.SerializeStr(result))

  198. 		err1 = json.Unmarshal(bytes, &result)

  199. 		if err1 != nil {

  200. 			return

  201. 		}

  202. 		if result.Code != 0 {

  203. 			if result.Msg != "" {

  204. 				err1 = errors.New(result.Msg)

  205. 				return

  206. 			}

  207. 			err1 = errors.New("请求智慧餐厅支付 异常/失败")

  208. 			return

  209. 		}

  210. 		resultMap, ok := result.Data.(map[string]interface{})

  211. 		if !ok {

  212. 			err1 = errors.New("获取 user_token 失败")

  213. 			return

  214. 		}

  215. 		if resultMap["code"].(string) != "10000" {

  216. 			return nil, resultMap

  217. 		}

  218. 		userToken = resultMap["token"].(string)

  219. 	}

  220. 

  221. 	//2、TODO::查询用户一脸通行开通状态：根据获取到的用户信息token，使用 alipay.commerce.educate.scene.token.query 接口查询用户人脸采集状态

  222. 	url := cfg.SmartCanteenPay + "/alipay/faceCollection/educateSceneTokenQuery"

  223. 	bytes, err := utils.CurlPost(url, utils.Serialize(map[string]string{

  224. 		"user_token": userToken,

  225. 	}), nil)

  226. 	if err != nil {

  227. 		return

  228. 	}

  229. 

  230. 	var result1 struct {

  231. 		Code int         `json:"code"`

  232. 		Msg  string      `json:"msg"`

  233. 		Data interface{} `json:"data"`

  234. 	}

  235. 	utils.FilePutContents("CurlEducateSceneTokenQuery", utils.SerializeStr(result1))

  236. 	err = json.Unmarshal(bytes, &result1)

  237. 	if err != nil {

  238. 		return

  239. 	}

  240. 	if result1.Code != 0 {

  241. 		if result1.Msg != "" {

  242. 			err = errors.New(result1.Msg)

  243. 			return

  244. 		}

  245. 		err = errors.New("请求智慧餐厅支付 异常/失败")

  246. 		return

  247. 	}

  248. 	// 更新/新增 `self_support_for_user_facel_info`

  249. 	selfSupportForUserFaceInfoDb := db.SelfSupportForUserFaceInfoDb{}

  250. 	selfSupportForUserFaceInfoDb.Set(userIdentityId)

  251. 	info, err := selfSupportForUserFaceInfoDb.GetSelfSupportForUserFaceInfo()

  252. 	if err != nil {

  253. 		return

  254. 	}

  255. 

  256. 	now := time.Now().Format("2006-01-02 15:04:05")

  257. 	var res map[string]string

  258. 	utils.Unserialize([]byte(utils.SerializeStr(result1.Data)), &res)

  259. 

  260. 	if info == nil {

  261. 		info = &model.SelfSupportForUserFaceInfo{

  262. 			UserIdentityId:          userIdentityId,

  263. 			CollectFaceType:         1,

  264. 			SchoolCode:              res["school_code"],

  265. 			SchoolStdCode:           res["school_std_code"],

  266. 			ParentUserId:            res["parent_user_id"],

  267. 			ParentLogonId:           res["parent_logon_id"],

  268. 			UserId:                  res["user_id"],

  269. 			SchoolFacePassStatus:    res["school_face_pass_status"],

  270. 			SchoolFacePaymentStatus: res["school_face_payment_status"],

  271. 			CreateAt:                now,

  272. 			UpdateAt:                now,

  273. 		}

  274. 		_, err2 := selfSupportForUserFaceInfoDb.SelfSupportForUserFaceInfoInsert(info)

  275. 		if err2 != nil {

  276. 			return err2, nil

  277. 		}

  278. 	} else {

  279. 		info.ParentUserId = res["parent_user_id"]

  280. 		info.ParentLogonId = res["parent_logon_id"]

  281. 		info.UserId = res["user_id"]

  282. 		info.SchoolFacePassStatus = res["school_face_pass_status"]

  283. 		info.SchoolFacePaymentStatus = res["school_face_payment_status"]

  284. 		info.UpdateAt = now

  285. 		_, err2 := selfSupportForUserFaceInfoDb.SelfSupportForUserFaceInfoUpdate(info, "parent_user_id", "parent_logon_id", "user_id", "school_face_pass_status", "school_face_payment_status", "update_at")

  286. 		if err2 != nil {

  287. 			return err2, nil

  288. 		}

  289. 	}

  290. 

  291. 	return nil, result1.Data

  292. }

  293. 

  294. func CurlEducateSceneTokenCreateForApplet(args md.CurlEducateSceneTokenReq) (err error, resp interface{}) {

  295. 	utils.FilePutContents("CurlEducateSceneTokenCreateForApplet", utils.SerializeStr(map[string]interface{}{

  296. 		"args": args,

  297. 	}))

  298. 

  299. 	//1、TODO::生成用户信息token(使用 alipay.commerce.educate.scene.token.create 接口生成用户信息token)

  300. 	url := cfg.SmartCanteenPay + "/alipay/faceCollection/educateSceneTokenCreate"

  301. 	bytes, err := utils.CurlPost(url, utils.Serialize(map[string]interface{}{

  302. 		"config": map[string]string{

  303. 			"ali_app_id":      args.Config.AliAppId,

  304. 			"ali_private_key": args.Config.AliPrivateKey,

  305. 			"ali_public_key":  args.Config.AliPublicKey,

  306. 		},

  307. 		"cert_no":         args.CertNo,

  308. 		"school_std_code": args.SchoolStdCode,

  309. 		"student_name":    args.StudentName,

  310. 		"out_user_id":     args.OutUserId,

  311. 		"cert_type":       "1",

  312. 		"sub_code":        "SCHOOL_FACE_PASS_NAVIGATE",

  313. 	}), nil)

  314. 	if err != nil {

  315. 		return

  316. 	}

  317. 	var result struct {

  318. 		Code int         `json:"code"`

  319. 		Msg  string      `json:"msg"`

  320. 		Data interface{} `json:"data"`

  321. 	}

  322. 	utils.FilePutContents("CurlEducateSceneTokenCreateForApplet", utils.SerializeStr(result))

  323. 	err = json.Unmarshal(bytes, &result)

  324. 	if err != nil {

  325. 		return

  326. 	}

  327. 	if result.Code != 0 {

  328. 		if result.Msg != "" {

  329. 			err = errors.New(result.Msg)

  330. 			return

  331. 		}

  332. 		err = errors.New("请求智慧餐厅支付 异常/失败")

  333. 		return

  334. 	}

  335. 

  336. 	return nil, result.Data

  337. }

  338. 

  339. func CurlEducateSceneTokenCreateForConcentratedCollectApplet(args md.CurlEducateSceneTokenReq) (err error, resp interface{}) {

  340. 	utils.FilePutContents("CurlEducateSceneTokenCreateForConcentratedCollectApplet", utils.SerializeStr(map[string]interface{}{

  341. 		"args": args,

  342. 	}))

  343. 

  344. 	//1、TODO::生成用户信息token(使用 alipay.commerce.educate.scene.token.create 接口生成用户信息token)

  345. 	url := cfg.SmartCanteenPay + "/alipay/faceCollection/educateSceneTokenCreate"

  346. 	bytes, err := utils.CurlPost(url, utils.Serialize(map[string]interface{}{

  347. 		"config": map[string]string{

  348. 			"ali_app_id":      args.Config.AliAppId,

  349. 			"ali_private_key": args.Config.AliPrivateKey,

  350. 			"ali_public_key":  args.Config.AliPublicKey,

  351. 		},

  352. 		"cert_no":          args.CertNo,

  353. 		"school_std_code":  args.SchoolStdCode,

  354. 		"student_name":     args.StudentName,

  355. 		"out_user_id":      args.OutUserId,

  356. 		"cert_type":        "1",

  357. 		"sub_code":         "SCHOOL_PAYMENT_REMOTE_OPEN_ACCOUNT",

  358. 		"operator_user_id": args.OperatorUserId, //采集人员的支付宝会员标识。（当sub_code为SCHOOL_PAYMENT_REMOTE_OPEN_ACCOUNT时，当前参数必选）

  359. 	}), nil)

  360. 	if err != nil {

  361. 		return

  362. 	}

  363. 	var result struct {

  364. 		Code int         `json:"code"`

  365. 		Msg  string      `json:"msg"`

  366. 		Data interface{} `json:"data"`

  367. 	}

  368. 	utils.FilePutContents("CurlEducateSceneTokenCreateForConcentratedCollectApplet", utils.SerializeStr(result))

  369. 	err = json.Unmarshal(bytes, &result)

  370. 	if err != nil {

  371. 		return

  372. 	}

  373. 	if result.Code != 0 {

  374. 		if result.Msg != "" {

  375. 			err = errors.New(result.Msg)

  376. 			return

  377. 		}

  378. 		err = errors.New("请求智慧餐厅支付 异常/失败")

  379. 		return

  380. 	}

  381. 

  382. 	return nil, result.Data

  383. }

  384. 

  385. func CurlEducateFacepayApply(args md.CurlEducateFacepayApplyReq) (err error, resp interface{}) {

  386. 	utils.FilePutContents("CurlEducateFacepayApply", utils.SerializeStr(map[string]interface{}{

  387. 		"args": args,

  388. 	}))

  389. 

  390. 	//1、TODO::alipay.commerce.educate.facepay.apply(人脸开通支付申请)

  391. 	url := cfg.SmartCanteenPay + "/alipay/faceScanPay/educateFacepayApply"

  392. 	bytes, err := utils.CurlPost(url, utils.Serialize(map[string]interface{}{

  393. 		"config": map[string]string{

  394. 			"ali_app_id":      args.Config.AliAppId,

  395. 			"ali_private_key": args.Config.AliPrivateKey,

  396. 			"ali_public_key":  args.Config.AliPublicKey,

  397. 		},

  398. 		"face_uid":        args.FaceUid,

  399. 		"school_std_code": args.SchoolStdCode,

  400. 		"face_open_id":    args.FaceOpenId,

  401. 	}), nil)

  402. 	if err != nil {

  403. 		return

  404. 	}

  405. 	var result struct {

  406. 		Code int         `json:"code"`

  407. 		Msg  string      `json:"msg"`

  408. 		Data interface{} `json:"data"`

  409. 	}

  410. 	utils.FilePutContents("CurlEducateFacepayApply", utils.SerializeStr(result))

  411. 	err = json.Unmarshal(bytes, &result)

  412. 	if err != nil {

  413. 		return

  414. 	}

  415. 	if result.Code != 0 {

  416. 		if result.Msg != "" {

  417. 			err = errors.New(result.Msg)

  418. 			return

  419. 		}

  420. 		err = errors.New("请求智慧餐厅支付 异常/失败")

  421. 		return

  422. 	}

  423. 

  424. 	return nil, result.Data

  425. }

  426. 

  427. func CurlAlipayPlanetEcocampusApiRosterSignUpInfo(args md.CurlAlipayPlanetEcocampusApiRosterSignUpInfoReq) (err error, resp interface{}) {

  428. 	url := cfg.SmartCanteenPay + "/alipay/bPass/alipayPlanetEcocampusApiRosterSignUpInfo"

  429. 	utils.FilePutContents("CurlAlipayPlanetEcocampusApiRosterSignUpInfo", utils.SerializeStr(map[string]interface{}{

  430. 		"args": args,

  431. 	}))

  432. 	bytes, err := utils.CurlPost(url, utils.Serialize(args), nil)

  433. 	if err != nil {

  434. 		return

  435. 	}

  436. 	var result struct {

  437. 		Code int         `json:"code"`

  438. 		Msg  string      `json:"msg"`

  439. 		Data interface{} `json:"data"`

  440. 	}

  441. 	utils.FilePutContents("CurlAlipayPlanetEcocampusApiRosterSignUpInfo", utils.SerializeStr(result))

  442. 	err = json.Unmarshal(bytes, &result)

  443. 	if err != nil {

  444. 		return

  445. 	}

  446. 	if result.Code != 0 {

  447. 		if result.Msg != "" {

  448. 			err = errors.New(result.Msg)

  449. 			return

  450. 		}

  451. 		err = errors.New("请求智慧餐厅支付 异常/失败")

  452. 		return

  453. 	}

  454. 	return nil, result.Data

  455. }