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

package com.szwl.controller;


import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.util.StrUtil;
import com.alibaba.fastjson.JSONObject;
import com.baomidou.mybatisplus.core.conditions.query.LambdaQueryWrapper;
import com.huifu.bspay.sdk.opps.core.exception.BasePayException;
import com.szwl.constant.HuifuConstant;
import com.szwl.constant.ResponseCodesEnum;
import com.szwl.model.bo.R;
import com.szwl.model.bo.ResponseModel;
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;

/**
 * <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("/addMerchant")
    public ResponseModel<?> addMerchant(@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");
            if(tHuifuMchCheck.getType().equals("0")) {
                if(StringUtils.isNotEmpty(huifuMchCheck.getCardFrontPic())
                        && StringUtils.isNotEmpty(huifuMchCheck.getLegalCertBackPic()) && StringUtils.isNotEmpty(huifuMchCheck.getLegalCertFrontPic()) ) {
                    tHuifuMchCheck.setStatus("1");
                }
            } else  {
                if(StringUtils.isNotEmpty(huifuMchCheck.getCertFrontPic())
                        && StringUtils.isNotEmpty(huifuMchCheck.getCertBackPic()) && StringUtils.isNotEmpty(huifuMchCheck.getLicensePic())
                        && StringUtils.isNotEmpty(huifuMchCheck.getRegAcctPic())) {
                    tHuifuMchCheck.setStatus("1");
                }
            }
            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("/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 = "审核商户入驻")
    @GetMapping ("/auditAddMerchant")
    public ResponseModel<?> auditAddMerchant(Long id, String status) throws Exception {
        if (id == null) {
            return R.fail(ResponseCodesEnum.A0001);
        }
        // 找到用户id对应的审核信息
        THuifuMchCheck huifuMchCheck = tHuifuMchCheckService.getById(id);
        String data = null;
        if(status.equals("1")) {
            LambdaQueryWrapper<THuifuMch> queryWrapper = new LambdaQueryWrapper<>();
            queryWrapper.eq(THuifuMch::getAdminId, huifuMchCheck.getAdminId());
            THuifuMch tHuifuMch = tHuifuMchService.getOne(queryWrapper);
            if(tHuifuMch != null) {
                return R.ok("商户已入驻，请勿重复入驻");
            }
            //通过
            // 判断商户类型，“0”为个人，“1”为企业
            if(huifuMchCheck.getType().equals("0")) {
                data = tHuifuMchService.addPersonage(huifuMchCheck);
            } else {
                data = tHuifuMchService.addEnterprise(huifuMchCheck);
            }
            // 判断是否入驻成功
            String success = "success";
            // 判断是否修改成功
            if(success.equals(data)) {
                return R.ok();
            } else {
                return R.fail(ResponseCodesEnum.A0001,data);
            }
        } else {
            // 拒绝
            huifuMchCheck.setModifyDate(new Date());
            huifuMchCheck.setStatus("3");
            tHuifuMchCheckService.updateById(huifuMchCheck);
            return R.ok();
        }
    }

    @ApiOperation(value = "审核商户修改")
    @GetMapping("/auditUpdateMerchant")
    public ResponseModel<?> auditUpdateMerchant(Long id, String status) throws Exception {
        if (id == null) {
            return R.fail(ResponseCodesEnum.A0001);
        }
        // 找到id对应的审核信息
        THuifuMchCheck huifuMchCheck = tHuifuMchCheckService.getById(id);
        if(status.equals("1")) {
            // 同意
            String data = tHuifuMchService.updateMerchant(huifuMchCheck);
            String success = "success";
            // 判断是否修改成功
            if(success.equals(data)) {
                return R.ok();
            } else {
                return R.fail(ResponseCodesEnum.A0001,data);
            }
        } else {
            // 拒绝
            huifuMchCheck.setModifyDate(new Date());
            huifuMchCheck.setStatus("3");
            tHuifuMchCheckService.updateById(huifuMchCheck);
            return R.ok();
        }
    }

    @ApiOperation(value = "上传材料图片")
    @PostMapping("/uploadPic")
    public ResponseModel<?> uploadPic(@RequestParam("file") MultipartFile file,
                                      @RequestParam("adminId") Long adminId,
                                      @RequestParam("fileType") String fileType){
        if (adminId == null) {
            return R.fail(ResponseCodesEnum.A0001);
        }
        // 找到用户id对应的审核信息
        LambdaQueryWrapper<THuifuMchCheck> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(THuifuMchCheck::getAdminId,adminId);
        THuifuMchCheck tHuifuMchCheck = tHuifuMchCheckService.getOne(queryWrapper);
        if(tHuifuMchCheck == null) {
            return R.fail(ResponseCodesEnum.A0206,"还未填写个人资料");
        }
        String result = "";
        if(file != null) {
            try{
                if(fileType.equals(HuifuConstant.fileType.F02.toString())) {
                    result = tHuifuMchService.uploadPic(file, HuifuConstant.fileType.F02);
                    tHuifuMchCheck.setCardFrontPic(result);
                } else if (fileType.equals(HuifuConstant.fileType.F03.toString())){
                    result = tHuifuMchService.uploadPic(file, HuifuConstant.fileType.F03);
                    tHuifuMchCheck.setCertBackPic(result);
                } else if (fileType.equals(HuifuConstant.fileType.F13.toString())) {
                    result = tHuifuMchService.uploadPic(file, HuifuConstant.fileType.F13);
                    tHuifuMchCheck.setCardFrontPic(result);
                } else if (fileType.equals(HuifuConstant.fileType.F07.toString())) {
                    result = tHuifuMchService.uploadPic(file, HuifuConstant.fileType.F07);
                    tHuifuMchCheck.setLicensePic(result);
                } else if (fileType.equals(HuifuConstant.fileType.F08.toString())) {
                    result = tHuifuMchService.uploadPic(file, HuifuConstant.fileType.F08);
                    tHuifuMchCheck.setRegAcctPic(result);
                } else if (fileType.equals(HuifuConstant.fileType.F40.toString())) {
                    result = tHuifuMchService.uploadPic(file, HuifuConstant.fileType.F40);
                    tHuifuMchCheck.setLegalCertFrontPic(result);
                } else if (fileType.equals(HuifuConstant.fileType.F41.toString())) {
                    result = tHuifuMchService.uploadPic(file, HuifuConstant.fileType.F41);
                    tHuifuMchCheck.setLegalCertBackPic(result);
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        if(StrUtil.isNotEmpty(result)) {
            tHuifuMchCheckService.updateById(tHuifuMchCheck);
            return R.ok("上传成功").setData(result);
        } else {
            return R.fail(ResponseCodesEnum.F0000,"上传失败");
        }
    }

    @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");
        System.out.println("data:" + data);
        System.out.println("audit_status:" + auditStatus);
        System.out.println("audit_desc:" + auditDesc);
        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 = "发送验证码")
    @GetMapping("/sendSms")
    public ResponseModel<?> sendSms(@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.sendSms(tHuifuMch);
        if(result.equals("00000000")) {
            return R.ok(tHuifuMch);
        } else {
            return R.fail(ResponseCodesEnum.A0001,"验证码发送失败");
        }
    }

    @ApiOperation(value = "上传材料图片")
    @PostMapping("/newUploadPic")
    public ResponseModel<?> newUploadPic(@RequestBody UploadParms uploadParms){
        Long adminId = uploadParms.getAdminId();
        String base64Str = uploadParms.getBase64Str();
        String fileType = uploadParms.getFileType();
        if (adminId == null) {
            return R.fail(ResponseCodesEnum.A0001);
        }
        // 找到用户id对应的审核信息
        LambdaQueryWrapper<THuifuMchCheck> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(THuifuMchCheck::getAdminId,adminId);
        THuifuMchCheck tHuifuMchCheck = tHuifuMchCheckService.getOne(queryWrapper);
        if(tHuifuMchCheck == null) {
            return R.fail(ResponseCodesEnum.A0206,"还未填写个人资料");
        }
        String result = "";
        String huifuId = null;
        if(StringUtils.isNotEmpty(tHuifuMchCheck.getHuifuId())) {
            huifuId = tHuifuMchCheck.getHuifuId();
        }
        if(StringUtils.isNotEmpty(base64Str)) {
            try{
                if(fileType.equals(HuifuConstant.fileType.F02.toString())) {
                    result = tHuifuMchService.newUploadPic(base64Str, HuifuConstant.fileType.F02, huifuId);
                    tHuifuMchCheck.setLegalCertFrontPic(result);
                } else if (fileType.equals(HuifuConstant.fileType.F03.toString())){
                    result = tHuifuMchService.newUploadPic(base64Str, HuifuConstant.fileType.F03, huifuId);
                    tHuifuMchCheck.setLegalCertBackPic(result);
                } else if (fileType.equals(HuifuConstant.fileType.F13.toString())) {
                    result = tHuifuMchService.newUploadPic(base64Str, HuifuConstant.fileType.F13, huifuId);
                    tHuifuMchCheck.setCardFrontPic(result);
                } else if (fileType.equals(HuifuConstant.fileType.F07.toString())) {
                    result = tHuifuMchService.newUploadPic(base64Str, HuifuConstant.fileType.F07, huifuId);
                    tHuifuMchCheck.setLicensePic(result);
                } else if (fileType.equals(HuifuConstant.fileType.F08.toString())) {
                    result = tHuifuMchService.newUploadPic(base64Str, HuifuConstant.fileType.F08, huifuId);
                    tHuifuMchCheck.setRegAcctPic(result);
                } else if (fileType.equals(HuifuConstant.fileType.F40.toString())) {
                    result = tHuifuMchService.newUploadPic(base64Str, HuifuConstant.fileType.F40, huifuId);
                    tHuifuMchCheck.setLegalCertFrontPic(result);
                } else if (fileType.equals(HuifuConstant.fileType.F41.toString())) {
                    result = tHuifuMchService.newUploadPic(base64Str, HuifuConstant.fileType.F41, huifuId);
                    tHuifuMchCheck.setLegalCertBackPic(result);
                } else if (fileType.equals(HuifuConstant.fileType.F55.toString())) {
                    result = tHuifuMchService.newUploadPic(base64Str, HuifuConstant.fileType.F55, huifuId);
                    tHuifuMchCheck.setCertFrontPic(result);
                } else if (fileType.equals(HuifuConstant.fileType.F56.toString())) {
                    result = tHuifuMchService.newUploadPic(base64Str, HuifuConstant.fileType.F56, huifuId);
                    tHuifuMchCheck.setCertBackPic(result);
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        if(StrUtil.isNotEmpty(result)) {
            tHuifuMchCheckService.updateById(tHuifuMchCheck);
            return R.ok("上传成功").setData(result);
        } else {
            return R.fail(ResponseCodesEnum.F0000,"上传失败");
        }
    }

    @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);
    }

}