th_net_hospital_ali_mp/antbuilder/industry/hospitalV2/components/hospital-payment-detail-yibao/index.js

import qs from "qs";
import { getYbParams, generateRandomFourDigitNumber } from "./service";
import { tradePay } from "../../utils/tradePay";
import {
	prePayConfirm,
	getPayAuthInfo,
	revokeSettle,
} from "../../../../core/utils/ywtService";
import history from "../../utils/history";
import { createSubscribe } from "applet-page-component";

Component(
	createSubscribe({
		onShow() {
			this.init("onShow");
			console.log("onShow this._paying", this._paying);
		},
	})({
		props: {},
		data: {
			authCode: undefined,
			canPay: false,
			prescriptionList: [],
			actionsheetVisible: false,
			isUserPersonalAccount: false, // 医保正式环境测试，默认不使用个账进行支付
			isCulculate: false,
			preConfirmInfo: {},
		},

		didMount() {
			this.init("didMount");
			console.log("didMount this._paying", this._paying);
		},

		didUnmount() {
			this._paying = false;
		},

		methods: {
			init(type) {
				this.getPayDetail(this.$page.data.query);
				this.hanldeGetPayAuthInfo(type);
			},

			async hanldeGetPayAuthInfo(type) {
				if (this._paying) return;
				const app = getApp();
				const {
					hisOrderNo: hisOrdNum,
					authCode,
					reqBizNo,
				} = this.$page.data.query;
				const _this = this;
				const ramdonNum = generateRandomFourDigitNumber();
				const userId = app.globalData.ywtUserId || "";
				const queryReqBizNo = reqBizNo || `${hisOrdNum}-${userId}-${ramdonNum}`;
				const query = Object.assign(this.$page.data.query, {
					reqBizNo: queryReqBizNo,
				});
				const qsResult = `?${qs.stringify(query)}`;
				const callUrl = encodeURIComponent(
					`antbuilder/industry/hospitalV2/pages/page-no-pull/index${qsResult}`
				);
				if (type === "onShow") {
					my.getAuthCode({
						scopes: ["nhsamp", "auth_user"], // 主动授权：auth_user，静默授权：auth_base。或者其它scopes
						success: (res) => {
							if (res.authCode) {
								_this.requestGetPayAuthInfo(
									res.authCode,
									callUrl,
									queryReqBizNo,
									type
								);
							}
						},
					});
				} else {
					this.requestGetPayAuthInfo(authCode, callUrl, queryReqBizNo, type);
				}
			},

			async requestGetPayAuthInfo(authCode, callUrl, reqBizNo, lifeType) {
				my.showLoading({ mask: true });
				const _this = this;
				const [err, result] = await getPayAuthInfo({
					authCode,
					callUrl,
					reqBizNo,
				});
				if (!err) {
					my.hideLoading();
					const { payAuthNo, authNo, medicalCardInstId, medicalCardId } =
						result;
					if (result.authNo) {
						this.setData(
							{
								payAuthNo,
								authNo,
								medicalCardInstId,
								medicalCardId,
								isCulculate: true,
							},
							() => {
								_this.handlePrePayConfirm();
							}
						);
						return;
					}
					if (result.authUrl && lifeType === "didMount") {
						// 跳转医保授权页面
						my.ap.openURL({
							url: result.authUrl,
							fail(e) {
								console.log("err", e);
								my.navigateBack();
							},
						});
					} else {
						my.navigateBack();
					}
				} else {
					my.hideLoading();
					my.showToast({
						type: "fail",
						content: err.info || "未知错误",
						duration: 2000,
						complete() {
							my.navigateBack();
						},
					});
				}
			},

			async handlePrePayConfirm() {
				my.showLoading({ mask: true });
				const {
					hisOrderNo: hisOrdNum,
					hisPatientId: patientId,
					hisClinicCode: clinicCode,
					total: orderSum,
					orderInsType,
				} = this.$page.data.query;
				const {
					payAuthNo,
					authNo,
					medicalCardInstId,
					medicalCardId,
					isUserPersonalAccount,
				} = this.data;

				const [err, result] = await prePayConfirm({
					patientId,
					clinicCode,
					hisOrdNum,
					orderSum,
					payInsType: "2",
					orderInsType,
					payAuthNo,
					authNo,
					medicalCardInstId,
					medicalCardId,
					consumeType: isUserPersonalAccount ? 0 : 2,
				});
				if (!err) {
					// 预结算成功
					const ybData = await getYbParams(result);
					this.setData(
						{
							preConfirmInfo: Object.assign(result, ybData),
							isCulculate: false,
							canPay: true,
						},
						() => {
							my.hideLoading();
						}
					);
				} else {
					my.hideLoading();
					my.showToast({
						type: "fail",
						content: err.info || "未知错误",
						duration: 2000,
						complete() {
							my.navigateBack();
						},
					});
				}
			},
		},

		parseDetailItems(detailItems) {
			const list = detailItems
				? JSON.parse(decodeURIComponent(detailItems || ""))
				: [];
			const newList = list.map((item) => {
				return {
					label: `${item.itemName}*${item.itemNum}`,
					// subLabel: `${item.unit || ""}`,
					value: `${item.amount || 0}元`,
				};
			});
			return newList || [];
		},

		async handleIsUserPersonalAccount(e) {
			const _this = this;
			const { valuex } = e.currentTarget.dataset;
			const { hisOrderNo, hisPatientId } = this.$page.data.query;
			const { preConfirmInfo, isUserPersonalAccount } = this.data;
			if (isUserPersonalAccount === valuex) return;
			my.showLoading();
			this.setData(
				{
					isUserPersonalAccount: valuex,
					isCulculate: true,
				},
				async () => {
					const [err, result] = await revokeSettle({
						hisOrderNo,
						insuDivId: preConfirmInfo.insuDivId || "",
						hisPatientId,
						isInsV2: true,
					});
					if (!err) {
						_this.handlePrePayConfirm();
					} else {
						my.showToast({
							type: "fail",
							content: "撤销预结算失败",
							duration: 2000,
							complete() {
								my.hideLoading();
								my.navigateBack();
							},
						});
					}
				}
			);
		},

		getPayDetail(query) {
			let infoList = [];
			if (query) {
				infoList = [
					{
						title: "就诊信息",
						list: [
							// { label: "门诊类别", value: info.deptName },
							{ label: "门诊科室", value: query.deptName },
							{ label: "医生姓名", value: query.doctorName },
							{ label: "处方时间", value: query.prescribeDate },
							{
								label: "费用总额",
								value: parseFloat(query.total / 100, 2) || 0 + "元",
								highlight: true,
							},
						],
					},
					{
						title: "费用信息",
						list: this.parseDetailItems(query.orderItems),
					},
				];
				this.setData({ prescriptionList: infoList });
			}
		},

		// 查看更多
		openForm() {
			this.setData({
				expand: !this.data.expand,
			});
		},

		medicareExpand() {
			this.setData({
				medicareExpand: !this.data.medicareExpand,
			});
		},

		handleActionsheet() {
			this.setData({
				actionsheetVisible: !this.data.actionsheetVisible,
			});
		},

		// 发起支付
		async onPay(e) {
			const { canPay } = this.data;
			if (!canPay) return;
			this._paying = true;
			const {
				hisPatientId,
				age,
				sex,
				orderId,
				hisOrderNo,
				amount,
				deptName,
				doctorName,
				doctorCode,
				hisClinicCode,
				total,
				name,
				orderInsType,
				prescribeDate,
				payInsType = "2",
				medInsFee,
				selfFee,
				payName,
				patName,
				outTradeNo,
			} = this.$page.data.query;
			const {
				preConfirmInfo: { invoiceNo, insuAdmDr, insUploadFeeResp },
				isUserPersonalAccount,
			} = this.data;
			let result = false;
			try {
				my.showLoading();
				// 门诊订单
				result = await tradePay(
					{
						useBalance: false,
						useMedicare: true,
						outTradeNo,
						hisPatientId,
						age,
						sex,
						orderId,
						hisOrderNo,
						amount,
						deptName,
						doctorName,
						doctorCode,
						total,
						hisClinicCode,
						name,
						prescribeDate,
						orderInsType,
						payInsType,
						totalFee: total,
						medInsFee,
						selfFee,
						payName,
						patName,
						invoiceNo,
						insuAdmDr,
						insUploadFeeResp,
						consumeType: isUserPersonalAccount ? 0 : 2,
					},
					{
						tradeType: "Outpatient",
					}
				);
			} catch (error) {
				console.log("error ===>", error);
			} finally {
				my.hideLoading();
			}

			if (result) {
				this._paying = false;
				console.log("pay result ===>", result);
				// 支付成功后返回列表页
				// my.navigateBack();

				history.replace({
					title: "支付成功",
					query: {},
					pageType: "hospital-payment-detail-yibao-result",
				});
			} else {
				this._paying = false;
			}
		},
	})
);