tysk/tysk.go

package tysk

import (
	"gitea.cdlsxd.cn/self-tools/tysk/tysk_constant"
	"gitea.cdlsxd.cn/self-tools/tysk/tysk_entity"
)

type Tysk struct {
	UserName string // 用户名
	Env      string // 环境,测试：dev,不传默认正式
}

func NewTysk(userName string, opts ...Option) TyskFacade {
	tysk := &Tysk{UserName: userName}
	for _, opt := range opts {
		opt(tysk) // 应用选项
	}
	return tysk
}

type Option func(*Tysk)

func WithEnvTest() Option {
	return func(tysk *Tysk) {
		tysk.Env = "dev"
	}
}

func (g *Tysk) GetAccountBalance(accountList tysk_entity.GetAccountBalanceReq) (res map[tysk_constant.AccountNo]tysk_entity.GetAccountBalanceList, err error) {
	var result tysk_entity.AccountBalance

	err = g.handleRequest(tysk_constant.GetAccountBalance, g.handleReqStructToMap(accountList), &result)
	if err != nil {
		return
	}
	res = make(map[tysk_constant.AccountNo]tysk_entity.GetAccountBalanceList, len(result.UserDataList))
	for _, row := range result.UserDataList {
		res[row.AccountNo] = row
	}
	return
}

func (g *Tysk) GetTodayTransHis(todayTransHisReq tysk_entity.TodayTransHisReq) (res tysk_entity.TodayTransHisResp, err error) {
	err = g.handleRequest(tysk_constant.GetTodayTransHis, g.handleReqStructToMap(todayTransHisReq), &res)
	if err != nil {
		return
	}
	return
}

func (g *Tysk) GetAccountInfo(accountInfoReq tysk_entity.AccountInfoReq) (res tysk_entity.AccountInfoResp, err error) {
	err = g.handleRequest(tysk_constant.GetAccountInfo, g.handleReqStructToMap(accountInfoReq), &res)
	if err != nil {
		return
	}
	return
}

func (g *Tysk) ReceiptApply(receiptApplyReq tysk_entity.ReceiptApplyReq) (success bool, err error) {
	err = g.handleRequest(tysk_constant.ReceiptApply, g.handleReqStructToMap(receiptApplyReq), nil)
	if err != nil {
		return
	}
	return true, nil
}

func (g *Tysk) ReceiptQuery(receiptQueryReq tysk_entity.ReceiptQueryReq) (res tysk_entity.ReceiptQueryResp, err error) {
	err = g.handleRequest(tysk_constant.ReceiptQuery, g.handleReqStructToMap(receiptQueryReq), &res)
	if err != nil {
		return
	}
	return
}

func (g *Tysk) ReceiptDownload(receiptDownloadReq tysk_entity.ReceiptDownloadReq) (res tysk_entity.ReceiptDownloadResp, err error) {
	err = g.handleRequest(tysk_constant.ReceiptDownload, g.handleReqStructToMap(receiptDownloadReq), &res)
	if err != nil {
		return
	}
	return
}

func (g *Tysk) TransHisQueryApply(TransHisQueryApplyReq tysk_entity.TransHisQueryApplyReq) (res tysk_entity.TransHisQueryApplyResp, err error) {
	err = g.handleRequest(tysk_constant.TransHisQueryApply, g.handleReqStructToMap(TransHisQueryApplyReq), &res)
	if err != nil {
		return
	}
	return
}

func (g *Tysk) TransHisQuery(transHisReq tysk_entity.TransHisQueryReq) (res tysk_entity.TransHisQueryResp, err error) {
	err = g.handleRequest(tysk_constant.TransHisQuery, g.handleReqStructToMap(transHisReq), &res)
	if err != nil {
		return
	}
	return
}

func (g *Tysk) BalanceHisQueryApply(BalanceHisQueryApplyReq tysk_entity.BalanceHisQueryApplyReq) (res tysk_entity.BalanceHisQueryApplyResp, err error) {
	err = g.handleRequest(tysk_constant.BalanceHisQueryApply, g.handleReqStructToMap(BalanceHisQueryApplyReq), &res)
	if err != nil {
		return
	}
	return
}

func (g *Tysk) BalanceHisQuery(BalanceHisQueryReq tysk_entity.BalanceHisQueryReq) (res tysk_entity.BalanceHisQueryResp, err error) {
	err = g.handleRequest(tysk_constant.BalanceHisQuery, g.handleReqStructToMap(BalanceHisQueryReq), &res)
	if err != nil {
		return
	}
	return
}

func (g *Tysk) AccountsTransHisQuery(AccountsTransHisQueryReq tysk_entity.AccountsTransHisQueryReq) (res tysk_entity.AccountsTransHisQueryResp, err error) {
	err = g.handleRequest(tysk_constant.AccountsTransHisQuery, g.handleReqStructToMap(AccountsTransHisQueryReq), &res)
	if err != nil {
		return
	}
	return
}

func (g *Tysk) SinglePay(singlePayReq tysk_entity.SinglePayReq) (res tysk_entity.SinglePayResp, err error) {
	err = g.handleRequest(tysk_constant.SinglePay, g.handleReqStructToMap(singlePayReq), &res)
	if err != nil {
		return
	}
	return
}

func (g *Tysk) SinglePayQuery(singlePayQueryReq tysk_entity.SinglePayQueryReq) (res tysk_entity.SinglePayQueryResp, err error) {
	err = g.handleRequest(tysk_constant.SinglePayQuery, g.handleReqStructToMap(singlePayQueryReq), &res)
	if err != nil {
		return
	}
	return
}

func (g *Tysk) BatchPay(batchPayReq tysk_entity.BatchPayReq) (res tysk_entity.BatchPayResp, err error) {
	err = g.handleRequest(tysk_constant.BatchPay, g.handleReqStructToMap(batchPayReq), &res)
	if err != nil {
		return
	}
	return
}

func (g *Tysk) BatchPayQuery(batchPayQueryReq tysk_entity.BatchPayQueryReq) (res tysk_entity.BatchPayQueryResp, err error) {
	err = g.handleRequest(tysk_constant.BatchPayQuery, g.handleReqStructToMap(batchPayQueryReq), &res)
	if err != nil {
		return
	}
	return
}

func (g *Tysk) PayArrange(payArrangeReq tysk_entity.PayArrangeReq) (success bool, err error) {
	err = g.handleRequest(tysk_constant.PayArrange, g.handleReqStructToMap(payArrangeReq), nil)
	if err != nil {
		return
	}
	return true, nil
}

func (g *Tysk) PayArrangeQuery(PayArrangeQueryReq tysk_entity.PayArrangeQueryReq) (res tysk_entity.PayArrangeQueryResp, err error) {
	err = g.handleRequest(tysk_constant.PayArrangeQuery, g.handleReqStructToMap(PayArrangeQueryReq), &res)
	if err != nil {
		return
	}
	return
}

func (g *Tysk) PayArrangeBillQuery(PayArrangeBillQueryReq tysk_entity.PayArrangeBillQueryReq) (res tysk_entity.PayArrangeBillQueryResp, err error) {
	err = g.handleRequest(tysk_constant.PayArrangeBillQuery, g.handleReqStructToMap(PayArrangeBillQueryReq), &res)
	if err != nil {
		return
	}
	return
}

func (g *Tysk) BatchesPayArrangeBillQuery(BatchesPayArrangeBillQueryReq tysk_entity.BatchesPayArrangeBillQueryReq) (res tysk_entity.BatchesPayArrangeBillQueryResp, err error) {
	err = g.handleRequest(tysk_constant.BatchesPayArrangeBillQuery, g.handleReqStructToMap(BatchesPayArrangeBillQueryReq), &res)
	if err != nil {
		return
	}
	return
}

func (g *Tysk) TGBPay(TGBPayReq tysk_entity.TGBPayReq) (res tysk_entity.TGBPayResp, err error) {
	err = g.handleRequest(tysk_constant.TGBPay, g.handleReqStructToMap(TGBPayReq), &res)
	if err != nil {
		return
	}
	return
}

func (g *Tysk) RefundTransQuery(RefundTransQueryReq tysk_entity.RefundTransQueryReq) (res tysk_entity.RefundTransQueryResp, err error) {
	err = g.handleRequest(tysk_constant.RefundTransQuery, g.handleReqStructToMap(RefundTransQueryReq), &res)
	if err != nil {
		return
	}
	return
}

func (g *Tysk) BatchSalarySend(BatchSalarySendReq tysk_entity.BatchSalarySendReq) (res tysk_entity.BatchSalarySendResp, err error) {
	err = g.handleRequest(tysk_constant.BatchSalarySend, g.handleReqStructToMap(BatchSalarySendReq), &res)
	if err != nil {
		return
	}
	return
}

func (g *Tysk) BankInfoQuery(BankInfoQuery tysk_entity.BankInfoQueryReq) (res tysk_entity.BankInfoQueryResp, err error) {
	err = g.handleRequest(tysk_constant.BankInfoQuery, g.handleReqStructToMap(BankInfoQuery), &res)
	if err != nil {
		return
	}
	return
}

func (g *Tysk) BillList(BillListReq tysk_entity.BillListReq) (res tysk_entity.BillListResp, err error) {
	err = g.handleRequest(tysk_constant.BillList, g.handleReqStructToMap(BillListReq), &res)
	if err != nil {
		return
	}
	return
}

func (g *Tysk) BillDetail(BillDetailReq tysk_entity.BillDetailReq) (res tysk_entity.BillDetailResp, err error) {
	err = g.handleRequest(tysk_constant.BillList, g.handleReqStructToMap(BillDetailReq), &res)
	if err != nil {
		return
	}
	return
}