szwlServer/src/main/java/com/szwl/controller/THuifuMchController.java

package com.szwl.controller;


import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.bean.copier.CopyOptions;
import cn.hutool.core.util.StrUtil;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.baomidou.mybatisplus.core.toolkit.Wrappers;
import com.huifu.bspay.sdk.opps.core.exception.BasePayException;
import com.szwl.constant.HuifuConstant;
import com.szwl.constant.JoinpayConstant;
import com.szwl.constant.ResponseCodesEnum;
import com.szwl.exception.BizException;
import com.szwl.manager.TokenManager;
import com.szwl.model.bo.R;
import com.szwl.model.bo.ResponseModel;
import com.szwl.model.bo.UserDetailBO;
import com.szwl.model.entity.THuifuMch;
import com.szwl.model.entity.THuifuMchCheck;
import com.szwl.model.entity.TJoinpayMch;
import com.szwl.model.param.UploadParms;
import com.szwl.service.THuifuMchCheckService;
import com.szwl.service.THuifuMchService;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import org.apache.commons.lang.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;

import javax.servlet.http.HttpServletRequest;
import javax.validation.Valid;
import java.util.Date;
import java.util.Optional;

import static com.szwl.constant.ResponseCodesEnum.B0001;

/**
 * <p>
 * 前端控制器
 * </p>
 *
 * @author wuhs
 * @since 2023-07-12
 */
@Api(value = "/tHuifuMch", tags = {"汇付支付"})
@RestController
@RequestMapping("/tHuifuMch")
public class THuifuMchController {


    @Autowired
    private THuifuMchService tHuifuMchService;

    @Autowired
    private THuifuMchCheckService tHuifuMchCheckService;

    @ApiOperation(value = "商户入驻申请")
    @PostMapping("/addApplication")
    public ResponseModel<?> addApplication(@Valid @RequestBody THuifuMchCheck tHuifuMchCheck) {
        if (tHuifuMchCheck.getAdminId() == null) {
            return R.fail(ResponseCodesEnum.A0001);
        }
        LambdaQueryWrapper<THuifuMchCheck> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(THuifuMchCheck::getAdminId, tHuifuMchCheck.getAdminId());
        THuifuMchCheck huifuMchCheck = tHuifuMchCheckService.getOne(queryWrapper);
        if (huifuMchCheck != null) {
            tHuifuMchCheck.setModifyDate(new Date());
            tHuifuMchCheck.setStatus("0");
            tHuifuMchCheckService.updateById(tHuifuMchCheck);
            return R.ok();
        }
        tHuifuMchCheck.setCreateDate(new Date());
        tHuifuMchCheck.setModifyDate(new Date());
        tHuifuMchCheck.setStatus("0");
        tHuifuMchCheckService.save(tHuifuMchCheck);
        return R.ok();
    }

    @ApiOperation(value = "商户入网")
    @PostMapping("/createMch")
    public ResponseModel<?> createMch(@RequestBody THuifuMchCheck newHuifuMchCheck) {
        // 步骤
        Integer steps = newHuifuMchCheck.getBindingSteps();
        LambdaQueryWrapper<THuifuMchCheck> query = Wrappers.lambdaQuery();
        query.eq(THuifuMchCheck::getAdminId, newHuifuMchCheck.getAdminId());
        THuifuMchCheck tHuifuMchCheck = tHuifuMchCheckService.getOne(query);
        switch (steps) {
            case 0:
                // 提交证件信息
                newHuifuMchCheck.setBindingSteps(1);
                if (tHuifuMchCheck == null) {
                    // 没有，直接保存
                    newHuifuMchCheck.setCreateDate(new Date());
                    newHuifuMchCheck.setModifyDate(new Date());
                    tHuifuMchCheckService.save(newHuifuMchCheck);
                } else {
                    // 有，更新
                    tHuifuMchCheck.setModifyDate(new Date());
                    tHuifuMchCheck.setRegName(newHuifuMchCheck.getRegName());
                    tHuifuMchCheck.setType(newHuifuMchCheck.getType());
                    tHuifuMchCheck.setName(newHuifuMchCheck.getName());
                    tHuifuMchCheck.setPhone(newHuifuMchCheck.getPhone());
                    tHuifuMchCheck.setCertNo(newHuifuMchCheck.getCertNo());
                    tHuifuMchCheck.setCertValidityType(newHuifuMchCheck.getCertValidityType());
                    tHuifuMchCheck.setCertBeginDate(newHuifuMchCheck.getCertBeginDate());
                    tHuifuMchCheck.setCertEndDate(newHuifuMchCheck.getCertEndDate());
                    tHuifuMchCheck.setProvId(newHuifuMchCheck.getProvId());
                    tHuifuMchCheck.setAreaId(newHuifuMchCheck.getAreaId());
                    tHuifuMchCheck.setDistrictId(newHuifuMchCheck.getDistrictId());
                    tHuifuMchCheck.setLicenseValidityType(newHuifuMchCheck.getLicenseValidityType());
                    tHuifuMchCheck.setLicenseCode(newHuifuMchCheck.getLicenseCode());
                    tHuifuMchCheck.setLicenseBeginDate(newHuifuMchCheck.getLicenseBeginDate());
                    tHuifuMchCheck.setBindingSteps(1);
                    tHuifuMchCheckService.updateById(tHuifuMchCheck);
                }
                return R.ok();
            case 1:
                // 提交结算信息
                tHuifuMchCheck.setCardType(newHuifuMchCheck.getCardType());
                tHuifuMchCheck.setCardName(newHuifuMchCheck.getCardName());
                tHuifuMchCheck.setCardNo(newHuifuMchCheck.getCardNo());
                tHuifuMchCheck.setBranchCode(newHuifuMchCheck.getBranchCode());
                tHuifuMchCheck.setBankCode(newHuifuMchCheck.getBankCode());
                tHuifuMchCheck.setCardProvId(newHuifuMchCheck.getCardProvId());
                tHuifuMchCheck.setCardAreaId(newHuifuMchCheck.getCardAreaId());
                tHuifuMchCheck.setSettType(newHuifuMchCheck.getSettType());
                tHuifuMchCheck.setBindingSteps(2);
                tHuifuMchCheck.setModifyDate(new Date());
                tHuifuMchCheckService.updateById(tHuifuMchCheck);
                return R.ok();
            case 2:
                // 提交信息审核
                tHuifuMchCheck.setModifyDate(new Date());
                tHuifuMchCheck.setBindingSteps(3);
                String result = "";
                String huifuId = tHuifuMchCheck.getHuifuId();
                try {
                    if (StringUtils.isEmpty(huifuId)) {
                        // 没入网，创建接口
                        result = tHuifuMchService.openAccount(tHuifuMchCheck);
                    } else {
                        // 已入网，修改接口
                        result = HuifuConstant.SUCCESS;
                        tHuifuMchCheck.setStatus("4");
                        tHuifuMchCheckService.updateById(tHuifuMchCheck);
                    }
                } catch (Exception e) {
                    throw new RuntimeException(e);
                }
                if (HuifuConstant.SUCCESS.equals(result)) {
                    return R.ok();
                }
                return R.fail(result);
        }
        return R.fail(B0001);
    }

    @ApiOperation(value = "汇付业务开通(签约)")
    @GetMapping("/signCon")
    public ResponseModel<?> signCon(Long id) throws Exception {
        // 找到用户id对应的审核信息
        THuifuMchCheck huifuMchCheck = tHuifuMchCheckService.getById(id);
        String data = tHuifuMchService.openBusiness(huifuMchCheck);
        // 判断是否开户成功或业务开通成功
        if (data.equals(HuifuConstant.SUCCESS)) {
            return R.ok();
        }
        return R.fail(ResponseCodesEnum.A0001, data);
    }

    @ApiOperation("修改结算方式")
    @PostMapping("/updateSettlement")
    public ResponseModel<?> updateSettlement(@RequestBody THuifuMchCheck huifuMchCheck) {
        // 找到用户id对应的审核信息
        String result = "";
        try {
            LambdaQueryWrapper<THuifuMchCheck> query = Wrappers.lambdaQuery();
            query.eq(THuifuMchCheck::getAdminId, huifuMchCheck.getAdminId());
            THuifuMchCheck tHuifuMchCheck = tHuifuMchCheckService.getOne(query);
            tHuifuMchCheck.setSettType(huifuMchCheck.getSettType());
            result = tHuifuMchService.changeSettleType(tHuifuMchCheck);
            if (result.equals(HuifuConstant.SUCCESS)) {
                return R.ok();
            }
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
        return R.fail(ResponseCodesEnum.A0001, result);
    }

    @ApiOperation(value = "汇付用户开户或业务开通")
    @GetMapping("/openAccount")
    public ResponseModel<?> openAccount(Long id) throws Exception {
        if (id == null) {
            return R.fail(ResponseCodesEnum.A0001);
        }
        // 找到用户id对应的审核信息
        THuifuMchCheck huifuMchCheck = tHuifuMchCheckService.getById(id);
        String data = "";
        // 用户开户或业务开通
        if (huifuMchCheck.getStatus().equals("0")) {
            data = tHuifuMchService.openAccount(huifuMchCheck);
        } else if (huifuMchCheck.getStatus().equals("1") || huifuMchCheck.getStatus().equals("4")) {
            data = tHuifuMchService.openBusiness(huifuMchCheck);
        } else {
            return R.fail(ResponseCodesEnum.A0001);
        }
        // 判断是否开户成功或业务开通成功
        if (data.equals(HuifuConstant.SUCCESS)) {
            return R.ok();
        } else {
            return R.fail(ResponseCodesEnum.A0001, data);
        }
    }

    @ApiOperation("商户信息查询")
    @GetMapping("/getHuifuMch")
    public ResponseModel<?> getHuifuMch(Long adminId) {
        LambdaQueryWrapper<THuifuMchCheck> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(THuifuMchCheck::getAdminId, adminId);
        THuifuMchCheck huifuMchCheck = tHuifuMchCheckService.getOne(queryWrapper);
        String result = "";
        if (huifuMchCheck != null) {
            String huifuId = huifuMchCheck.getHuifuId();
            if (StringUtils.isNotEmpty(huifuId)) {
                try {
                    result = tHuifuMchService.getInfo(huifuMchCheck);
                } catch (BasePayException e) {
                    throw new RuntimeException(e);
                }
            }
        }
        return R.ok(result);
    }

    @ApiOperation(value = "商户增加取现业务")
    @GetMapping("/addCashBusiness")
    public ResponseModel<?> addCashBusiness(Long adminId) {
        LambdaQueryWrapper<THuifuMchCheck> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(THuifuMchCheck::getAdminId, adminId);
        THuifuMchCheck huifuMchCheck = tHuifuMchCheckService.getOne(queryWrapper);
        String result = "";
        if (huifuMchCheck != null) {
            try {
                result = tHuifuMchService.addCashBusiness(huifuMchCheck);
            } catch (Exception e) {
                throw new RuntimeException(e);
            }
        }
        return R.ok(result);
    }

    @ApiOperation(value = "商户修改申请")
    @PostMapping("/updateMerchant")
    public ResponseModel<?> updateMerchant(@Valid @RequestBody THuifuMchCheck tHuifuMchCheck) {
        if (tHuifuMchCheck.getAdminId() == null) {
            return R.fail(ResponseCodesEnum.A0001);
        }
        // 排除掉不复制的属性
        String[] ignoreProperties = {"id", "createDate", "adminId", "huifuId"};
        LambdaQueryWrapper<THuifuMchCheck> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(THuifuMchCheck::getAdminId, tHuifuMchCheck.getAdminId());
        THuifuMchCheck newHuifuMchCheck = tHuifuMchCheckService.getOne(queryWrapper);
        if (newHuifuMchCheck.getStatus().equals("3")) {
            BeanUtil.copyProperties(tHuifuMchCheck, newHuifuMchCheck, ignoreProperties);
            newHuifuMchCheck.setStatus("1");
        } else {
            BeanUtil.copyProperties(tHuifuMchCheck, newHuifuMchCheck, ignoreProperties);
            newHuifuMchCheck.setStatus("4");
        }
        newHuifuMchCheck.setCreateDate(new Date());
        newHuifuMchCheck.setModifyDate(new Date());
        tHuifuMchCheckService.updateById(newHuifuMchCheck);
        return R.ok();
    }

    @ApiOperation(value = "提交审核")
    @PostMapping("/submitCheck")
    public ResponseModel<?> submitCheck(@RequestBody THuifuMchCheck tHuifuMchCheck) {
        if (tHuifuMchCheck.getAdminId() == null) {
            return R.fail(ResponseCodesEnum.A0001);
        }
        // 找到用户id对应的审核信息
        LambdaQueryWrapper<THuifuMchCheck> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(THuifuMchCheck::getAdminId, tHuifuMchCheck.getAdminId());
        THuifuMchCheck huifuMchCheck = tHuifuMchCheckService.getOne(queryWrapper);
        huifuMchCheck.setStatus("1");
        tHuifuMchCheckService.updateById(huifuMchCheck);
        return R.ok();
    }

    @ApiOperation(value = "审核回调")
    @PostMapping("/auditNotify")
    public ResponseModel<?> auditNotify(HttpServletRequest request) {
        String data = request.getParameter("data");
        JSONObject jsonObject = JSONObject.parseObject(data);
        String auditStatus = jsonObject.getString("audit_status");
        String auditDesc = jsonObject.getString("audit_desc");
        return R.ok().setData(data);
    }

    @ApiOperation(value = "获取汇付商户号")
    @GetMapping("/getHuifuId")
    public ResponseModel<THuifuMch> getHuifuId(@RequestParam Long adminId) {
        if (adminId == null) {
            return R.fail(ResponseCodesEnum.A0001);
        }
        LambdaQueryWrapper<THuifuMch> wrapper = new LambdaQueryWrapper<>();
        wrapper.eq(THuifuMch::getAdminId, adminId);
        THuifuMch huifuMch = tHuifuMchService.getOne(wrapper);
        return R.ok(huifuMch);
    }

    @ApiOperation(value = "获取审核信息")
    @GetMapping("/getHuifuMchCheck")
    public ResponseModel<THuifuMchCheck> getHuifuMchCheck(@RequestParam Long adminId) {
        if (adminId == null) {
            return R.fail(ResponseCodesEnum.A0001);
        }
        LambdaQueryWrapper<THuifuMchCheck> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(THuifuMchCheck::getAdminId, adminId);
        THuifuMchCheck huifuMchCheck = tHuifuMchCheckService.getOne(queryWrapper);
        return R.ok(huifuMchCheck);
    }

    @ApiOperation(value = "更新签约状态")
    @PostMapping("/updateConStat")
    public ResponseModel<?> updateConStat(@RequestBody THuifuMchCheck huifuMchCheck) throws BasePayException {
        THuifuMchCheck tHuifuMchCheck = tHuifuMchCheckService.getById(huifuMchCheck.getId());
        String str = tHuifuMchService.updateConStat(tHuifuMchCheck);
        return R.ok(str);
    }

    @ApiOperation(value = "查询余额")
    @GetMapping("/checkBalance")
    public ResponseModel<?> checkBalance(@RequestParam Long adminId) throws Exception {
        if (adminId == null) {
            return R.fail(ResponseCodesEnum.A0001);
        }
        LambdaQueryWrapper<THuifuMch> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(THuifuMch::getAdminId, adminId);
        THuifuMch tHuifuMch = tHuifuMchService.getOne(queryWrapper);
        String result = tHuifuMchService.checkBalance(tHuifuMch.getHuifuId());
        return R.ok(result);
    }


}