对接飞书多维表格

ninth_spring

已于 2023-11-23 10:45:50 修改

阅读量412

点赞数

文章标签：飞书

于 2023-10-17 09:44:45 首次发布

本文链接：https://blog.csdn.net/ninth_spring/article/details/133876786

版权

多维表格数据新增，controller层

package com.porton.feishuintegration.controller;

import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.date.DateTime;
import cn.hutool.core.date.DateUtil;
import cn.hutool.core.util.ObjectUtil;
import cn.hutool.json.JSONUtil;
import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.google.gson.Gson;
import com.porton.feishuintegration.model.common.FeishuCommonResponseDto;
import com.porton.feishuintegration.model.common.ResultResponse;
import com.porton.feishuintegration.model.feishuBitable.*;
import com.porton.feishuintegration.model.feishuBitable.entity.ApplyDto;
import com.porton.feishuintegration.model.feishuBitable.entity.MaterialDetail;
import com.porton.feishuintegration.model.feishuBitable.entity.YldParam;
import com.porton.feishuintegration.service.FeishuBitableService;
import com.porton.feishuintegration.util.Utils;
import lombok.Data;
import lombok.extern.slf4j.Slf4j;
import org.apache.commons.lang3.StringUtils;
import org.apache.logging.log4j.util.Strings;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.logging.LoggerConfiguration;
import org.springframework.http.*;
import org.springframework.util.Assert;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.client.RestTemplate;
import sun.rmi.runtime.Log;

import java.math.BigDecimal;
import java.text.SimpleDateFormat;
import java.util.*;
import java.util.logging.Logger;

/**
 * @author
 * 多维表格
 */
@RequestMapping("/feishu/bitable/tables")
@RestController
@Slf4j
public class BitableController {

    @Autowired
    private FeishuBitableService bitableService;


//    @Autowired
//    private CommonServie commonServie;


    @Autowired
    private RestTemplate restTemplate;

    @PostMapping("/views")
    public FeishuBitableResponseDto batchAddUserForGroup(@RequestBody BitableTableIdParam param) {
        return bitableService.getAppData(param);
    }


    /***
     * 获取表格数据
     * @param param
     * @return
     */
    @PostMapping("/tables")
    public FeishuBitableResponseDto batchViewsAddUserForGroup(@RequestBody BitableTableIdParam param) {
        FeishuBitableResponseDto dto=new FeishuBitableResponseDto();
        //如果传app_token 和 table_id
        if (ObjectUtil.isNotEmpty(param.getAppToken()) && ObjectUtil.isNotEmpty(param.getTableId()) && ObjectUtil.isNotEmpty(param.getViewId())) {
            BitableTableIdParam appTokenParam = BeanUtil.copyProperties(param, BitableTableIdParam.class);
             dto = bitableService.getRecordsAppData(appTokenParam);
            return dto;
        }else {
            dto.setCode(400);
            dto.setMsg("appToken,tableId,viewId 为必传");
            return dto;
        }
    }


    @PostMapping("/getApplyMaterialList")
    public ApplyDto getApplyMaterialList(@RequestBody YldParam param) {
        ApplyDto applyDto=new ApplyDto();
        JSONObject urlParm = new JSONObject();
        if (Strings.isNotEmpty(param.getWerks())) {
            urlParm.put("WERKS", param.getWerks());
        }
        if (param.getRsnum() != null) {
            urlParm.put("RSNUM", param.getRsnum());
        }
        Map<String, Object> hashMap = new HashMap<>();
        hashMap.put("ZINPUT", urlParm);
        String s = JSON.toJSONString(hashMap);
        String s1 = JSONUtil.toJsonStr(hashMap);
        log.info("入参为=》{}", s);
        log.info("入参为=》{}", s1);

//        String str = restTemplate.postForObject("https://esb-test.porton.cn/restcloud/sap/zbpm_reservation_info", s, String.class);
        String res = Utils.sendPostO("https://esb-test.porton.cn/restcloud/sap/zbpm_reservation_info", s1);
        String ress = Utils.sendPostO("https://esb-test.porton.cn/restcloud/sap/zbpm_reservation_approval", s1);


//        String res = Utils.sendPostO(yldDataQueryUrl, s);
//        ResponseEntity<ResultResponse> results = restTemplate.postForEntity(yldDataQueryUrl,s, ResultResponse.class);
        Assert.isTrue(Strings.isNotEmpty(res), "接口错误，请联系管理员重试");

        JSONObject parse = JSONObject.parseObject(res);
        log.info("查询结果为=》{}", res);
        List<ApplyDto> applyDtos = JSONObject.parseArray(parse.get("ZOUT_HEAD").toString(), ApplyDto.class);
        if (applyDtos !=null && applyDtos.size()>0){
             applyDto = applyDtos.get(0);
            List<MaterialDetail> materialDetails = JSONObject.parseArray(parse.get("ZOUT_ITEM").toString(), MaterialDetail.class);
            applyDto.setDetailList(materialDetails);
        }
        return applyDto;

    }
//    @PostMapping("/tables")
//    public ResultResponse batchViewsAddUserForGroup(@RequestBody BitableTableIdParam param) {
//
//        ResultResponse viewsAppData=new ResultResponse();
//        //如果传app_token 和 table_id
//        if (ObjectUtil.isNotEmpty(param.getAppToken()) && ObjectUtil.isNotEmpty(param.getTableId())){
//            viewsAppData = bitableService.getAppTokentableIdAppData(param);
//            //如果只传如果传app_token
//        }else if (ObjectUtil.isNotEmpty(param.getAppToken())){
//            //复制参数
//            BitableAppTokenParam appTokenParam = BeanUtil.copyProperties(param, BitableAppTokenParam.class);
//            viewsAppData = bitableService.getAppTokenAppData(appTokenParam);
//        }else if (ObjectUtil.isNotEmpty(param.getAppToken()) && ObjectUtil.isNotEmpty(param.getTableId()) && ObjectUtil.isNotEmpty(param.getViewId())){
//            BitableTableIdParam appTokenParam = BeanUtil.copyProperties(param, BitableTableIdParam.class);
//            FeishuBitableResponseDto = bitableService.getRecordsAppData(appTokenParam);
//        }
//        return viewsAppData;
//    }


    /***
     * 新增数据表
     * @param param
     * @return
     */
    @PostMapping("/addBitTableForName")
    public FeishuCommonResponseDto addBitTableForName(@RequestBody AddTableIdParam param) {
        return bitableService.addBitTableForName(param);
    }



    /***
     * 新增多个数据表
     * @param param
     * @return
     */
    @PostMapping("/batchAddBitTableForNames")
    public FeishuCommonResponseDto BatchAddBitTableForNames(@RequestBody BatchAddTableIdParam param) {
        return bitableService.BatchAddBitTableForNames(param);
    }


    /**
     * 新增视图
     * @param param
     * @return
     */
    @PostMapping("/addBitTableForViews")
    public FeishuCommonResponseDto AddBitTableForViews(@RequestBody AddTableIdViewsParam param) {
        return bitableService.AddBitTableForViews(param);
    }


    /**
     * 删除视图
     * @param param
     * @return
     */
    @PostMapping("/deleteBitTableForViews")
    public FeishuCommonResponseDto deleteBitTableForViews(@RequestBody AddTableIdViewsParam param) {
        return bitableService.deleteBitTableForViews(param);
    }


    /**
     * 新增记录
     * @param param
     * @return
     */
    @PostMapping("/addBitTableForRecords")
    public FeishuCommonResponseDto addBitTableForRecords(@RequestBody AddRecordsParam param) {
        return bitableService.addBitTableForRecords(param);
    }


    /**
     * 新增多条记录
     * @param param
     * @return
     */
    @PostMapping("/batchAddBitTableForRecords")
    public FeishuCommonResponseDto batchAddBitTableForRecords(@RequestBody BatchAddRecordsParam param) {
        return bitableService.batchAddBitTableForRecords(param);
    }


    /**
     * 更新记录
     * @param param
     * @return
     */
    @PostMapping("/updateBitTableForRecords")
    public FeishuCommonResponseDto updateBitTableForRecords(@RequestBody UpdateRecordsParam param) {
        return bitableService.updateBitTableForRecords(param);
    }


    /**
     * 更新多条记录
     * @param param
     * @return
     */
    @PostMapping("/batchUpdateBitTableForRecords")
    public FeishuCommonResponseDto batchUpdateBitTableForRecords(@RequestBody BatchUpdateRecordsParam param) {
        return bitableService.batchUpdateBitTableForRecords(param);
    }


    /**
     * 列出字段
     * @param param
     * @return
     */
    @PostMapping("/queryBitTableForFields")
    public FeishuBitableResponseDto queryBitTableForFields(@RequestBody QueryFieldsParam param) {
        return bitableService.queryBitTableForFields(param);
    }


    /**
     * 新增字段
     * @param param
     * @return
     */
    @PostMapping("/addBitTableForFields")
    public FeishuCommonResponseDto addBitTableForFields(@RequestBody AddFieldsParam param) {
        return bitableService.addBitTableForFields(param);
    }


    /**
     * 更新字段
     * @param param
     * @return
     */
    @PostMapping("/updateBitTableForFields")
    public FeishuCommonResponseDto updateBitTableForFields(@RequestBody UpdateFieldsParam param) {
        return bitableService.updateBitTableForFields(param);
    }


    /**
     * 删除字段
     * @param param
     * @return
     */
    @PostMapping("/deleteBitTableForFields")
    public FeishuCommonResponseDto deleteBitTableForFields(@RequestBody UpdateFieldsParam param) {
        return bitableService.deleteBitTableForFields(param);
    }


    @PostMapping("/postBitTableForFields")
    public ResultResponse postBitTableForFields(@RequestBody Crmt crmt) {

        String fielStr=null;
        String exitTime = crmt.getExitTime();
        DateTime dateTime = DateUtil.parse(exitTime, "yyyy-MM-dd HH:mm:ss");
        System.out.println("日期==============="+dateTime);
        List<String> arrayList = new ArrayList<>();
        String fujian =crmt.getFileName();
        if (StringUtils.isNotEmpty(fujian)){
            String[] split = fujian.split(",");
            List<String> strings = Arrays.asList(split);
            if (strings !=null && strings.size()>0){
                for (String str:strings){
                   String strs = "https://bpm-pre.porton.cn/bpmapi/bpm/attachment/download/" + str+ "?attachmentType=bpm";
                    arrayList.add(strs);
                }
            }
            fielStr=arrayList.toString();
        }

        List<SeqData> objects = new ArrayList<>();
        for (int i=1;i<10;i++){
            SeqData seqData = new SeqData();
            Date date = new Date();
            SimpleDateFormat fmt = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
            String dateStr = fmt.format(date);
            seqData.setTimestamp(dateStr);
            seqData.setMessageTemplate("好辣鸡啊，阿根廷1234");

            objects.add(seqData);
        }
        HashMap<String, Object> hashMap = new HashMap<>();
        hashMap.put("events",objects);
        String jsonStr = JSONUtil.toJsonStr(hashMap);
//        String jsonStr = JSONUtil.toJsonStr(hashMap);
        crmt.setFileName(fielStr);
//        UserInformationDto czht = commonServie.getUserInfo(instanceInfo.getDrafter(), "ZJGCCRMT");
//        ResponseEntity<ResultResponse> results = restTemplate.postForEntity("https://vrms-test.porton.cn/btjdapi/api/ExitVoucher/Add",crmt, ResultResponse.class);
//        ResponseEntity<ResultResponse> results = restTemplate.postForEntity("http://btpcpi.yilvzp.com/api/ExitVoucher/Add",crmt, ResultResponse.class);
//        ResponseEntity<ResultResponse> results = restTemplate.postForEntity("https://vrmsfs-test.porton.cn/api/api/ExitVoucher/Add",crmt, ResultResponse.class);
        ResponseEntity<ResultResponse> results = restTemplate.postForEntity("http://10.200.24.51:8009/api/events/raw",jsonStr, ResultResponse.class);
//        String postsResult = Utils.sendPostO("http://10.200.24.51:8009/api/events/raw",jsonStr);

        JSONArray jArray = new JSONArray();
        jArray.add(hashMap);
        String str = jArray.toString();
        HttpHeaders headers = new HttpHeaders();
        headers.setBearerAuth("wX6rGbp7yKQOsALRnCGh");
        headers.setConnection("wX6rGbp7yKQOsALRnCGh");
//        RequestEntity<String> requestEntity = RequestEntity
//                .post("http://10.200.24.51:8009/api/events/raw")
//                .headers(headers)
//                .contentType(MediaType.APPLICATION_JSON)
//                .body(str);

//        restTemplate.put("http://10.200.24.51:8009/api/events/raw",jsonStr);
//        if (ObjectUtil.isNotEmpty(requestEntity)){
//            ResultResponse body = results.getBody();
//            ResultUserJobBpmDto resultDto = new Gson().fromJson(postsResult, ResultUserJobBpmDto.class);
//        }
//        ResultResponse body = results.getBody();
        setLogger（newLoggerConfiguration（）.writeTo（seq（“http://10.200.24.51::8009”））.创建记录器（））;日志。information（“Hello from {lang}！”，“Java”);
//                Log.setLogger(new LoggerConfiguration()
//                .writeTo(coloredConsole())
//                .writeTo(rollingFile("test-{Date}.log"), LogEventLevel.Information)
//                .writeTo(seq("http://localhost:5341/"))
//                .setMinimumLevel(LogEventLevel.Verbose)
//                .createLogger());
        return new ResultResponse();
    }




    @PostMapping("/postSapSend")
    public ResultResponse postSapSend(@RequestBody Crmt crmt) {

        String exitTime = crmt.getExitTime();
        DateTime dateTime = DateUtil.parse(exitTime, "yyyy-MM-dd HH:mm:ss");
        System.out.println("日期==============="+dateTime);


        String allotMoney = crmt.getApplyDepartment();
        BigDecimal bigDecimal = new BigDecimal(allotMoney);
        String s = bigDecimal.toPlainString();
//        UserInformationDto czht = commonServie.getUserInfo(instanceInfo.getDrafter(), "ZJGCCRMT");
        ResponseEntity<ResultResponse> results = restTemplate.postForEntity("https://vrms-test.porton.cn/btjdapi/api/ExitVoucher/Add",crmt, ResultResponse.class);

        if (ObjectUtil.isNotEmpty(results)){
            ResultResponse body = results.getBody();
        }
        ResultResponse body = results.getBody();
        return new ResultResponse();
    }



    @PostMapping("/postSapSendddjs")
    public void postSapSendddjs() {

        String url="https://esb-test.porton.cn/restcloud/ddjssq/apexrest/AcceptContracts";

        // 先获取token
        HttpHeaders requestHeaders = new HttpHeaders();
        Map<String, String> requestParam = new HashMap<>();
        requestParam.put("grant_type", "password");
        requestParam.put("client_id", "3MVG96vIeT8jJWjJT_fMo8DsIwIu0b49Qli6kfIXOCj2CnYdNj1T1utoTalPnTxCO5J_FsnUlhAGaxMbM017T");
        requestParam.put("client_secret", "6FDE5995D087638DBDC3AAAB64192DB43F59175ED1C38127C5CF3DA86767A6F7");
        requestParam.put("username", "chengzange_admin@frensworkz.com.devpharma");
        requestParam.put("password", "1qaz2WSX");
        HttpEntity requestEntity = new HttpEntity(requestParam, requestHeaders);
        CrmTokenDto tokenDto = restTemplate.postForObject("https://esb-test.porton.cn/restcloud/crm-test/token", requestEntity, CrmTokenDto.class);
        log.info(JSON.toJSONString(tokenDto));

        //请求头
        log.info(JSON.toJSONString(tokenDto));
        // 拼接token再去回调Update接口
        HttpHeaders headers = new HttpHeaders();
        headers.setBearerAuth(tokenDto.getAccess_token());
        headers.setContentType(MediaType.APPLICATION_JSON);
        //获取审批结果
//        ExecutorDto executorDto = flowExecutor.getExecutorDto();
//        log.info("流程参数有" + JSON.toJSONString(executorDto));
//        String approvalResult = executorDto.getApprovalResult();
//        Map<String, Object> bizData = executorDto.getBizData();

        List<JSONObject> jbarrayList = new ArrayList<>();

        JSONObject jb=new JSONObject();
//        String sfid = Obj2String(businessRule.get("SFID"));
//        jb.put("Contract_ID",sfid);
//        String double_chapter_contract =(String) bizData.get("DOUBLE_CHAPTER_CONTRACT");
        List<JSONObject> arrayList = new ArrayList<>();
//        if (StringUtils.isNotEmpty(double_chapter_contract)){
//            String[] strings = double_chapter_contract.split(",");
//            List<String> stringList = Arrays.asList(strings);
//            for (String str:stringList){
//                Map<String, Object> map = commonDao.selectAttById(str);
//                if (map !=null && !map.isEmpty()){
//                    JSONObject object = new JSONObject();
//                    object.put("Name","map");
//                    String linkUrl =  "/bpmapi/bpm/attachment/download/attachmentType=bpm";
//                    object.put("LinkUrl",linkUrl);
//                    object.put("ContractId","a05BK000001QA3ZYAW");
//                    arrayList.add(object);
//                }
//            }
//            jb.put("Files",double_chapter_contract);
//        }
//        if ("AGREED".equals(approvalResult)){
//            jb.put("Approval_Status","审批通过");
//            jb.put("Files",arrayList);
//        }else {
//            jb.put("Approval_Status","审批拒绝");
//            jb.put("Files","");
//        }
        jb.put("Approval_Status","审批通过");
        jb.put("Files",arrayList);
        jb.put("Contract_ID","a05BK000001QA3ZYAW");
        jbarrayList.add(jb);
        HttpEntity httpEntity = new HttpEntity(jbarrayList, headers);

        System.out.println("======"+httpEntity);
        System.out.println(JSON.toJSONString(jbarrayList));

        String res = restTemplate.postForObject(url, httpEntity, String.class);
        log.info("请求外部接口返回参数=》{}", res);
//        JSONObject jsonObj = JSON.parseObject(res);
//        if (Strings.isEmpty(res)){
//            log.info("接口错误，请联系管理员查看错误原因");
//        }
    }



    @GetMapping("/postSapSendxmwdckqxs")
    public void xmwdckqxsqEndTospStart() {

        log.info("====项目文档权限申请流程结束开始====");
//        log.info("项目文档权限申请-params参数有" + JSON.toJSONString(params));
        try{
          String url="https://esb-test.porton.cn/restcloud/portsite/webservice/ProjectDoc"+ "?InstanceId=" +"946788896833032192";
//            if ("End".equals(str) &&  "AGREED".equals(approvalResult)){

//                url=url+"&Status=2";
                url=url+"&Status=2";
//            }
//            if ("after".equals(str)){
//                url=url+"&Status=1";
//            }
            String res = Utils.sendByGet(url);
            if (Strings.isEmpty(res)){
                log.info("接口错误，请联系管理员查看错误原因");
            }
            log.info("请求外部接口返回参数=》{}", res);
            JSONObject jsonObj = JSON.parseObject(res);
            if (!"200".equals(jsonObj.get("Code").toString())){
                log.info(jsonObj.get("Message").toString());
            }
            // 保存请求接口日志
//            commonServie.saveLogAboutSendThirdApi(instanceInfo.getProcessname(), bpmtoSpUrl, JSON.toJSONString(url), res);
        } catch (Exception e) {
            log.error(e.getMessage(), e);
            log.error("项目文档权限申请节点通知SP系统接口失败，原因：" + e.getMessage());
        }
        log.info("====外项目文档权限申请程结束结束====");
    }

}

实现类：service层

package com.porton.feishuintegration.service;

import com.porton.feishuintegration.model.common.FeishuCommonResponseDto;
import com.porton.feishuintegration.model.common.ResultResponse;
import com.porton.feishuintegration.model.feishuBitable.*;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;

import java.util.List;
import java.util.Map;

/**
 * 飞书多维表格服务接口
 * 
 */
public interface FeishuBitableService {

    /**
     * 获取多维表格元数据
     * @param param
     * 多维表格ID
     * @return 多维表格信息
     */
//    FeishuBitableResponseDto getAppData(String appToken);
    FeishuBitableResponseDto getAppData(BitableTableIdParam param);


    /***
     * 获取多维表格
     * 表格里的视图
     * 视图级
     * 第二层
     * @param param
     * @return
     */
    ResultResponse getAppTokentableIdAppData(BitableTableIdParam param);


    /***
     * 获取多维表格
     * 表格级
     * 列出数据表
     * 第一层
     * @param param
     * @return
     */
    ResultResponse getAppTokenAppData(BitableAppTokenParam param);


    /***
     * 获取多维表格
     * 单元格数据
     *
     * @param param
     * @return
     */
    FeishuBitableResponseDto getAppTokentableIdFormIdAppData(BitableFormIdParam param);


    /**
     * 获取多维表格
     * 列出记录
     * 明细数据
     * 第三层
     * @param param
     * @return
     */
    FeishuBitableResponseDto getRecordsAppData(BitableTableIdParam param);



    FeishuBitableResponseDto getRecordsRecursionAppData(BitableTableIdParam param);


    /***
     * 新增数据表
     * @param param
     * @return
     */
    FeishuCommonResponseDto addBitTableForName(AddTableIdParam param);


    /***
     * 新增多个数据表
     * 批量新增
     * @param param
     * @return
     */
    FeishuCommonResponseDto BatchAddBitTableForNames(BatchAddTableIdParam param);


    FeishuCommonResponseDto AddBitTableForViews(AddTableIdViewsParam param);


    FeishuCommonResponseDto deleteBitTableForViews(AddTableIdViewsParam param);



    /**
     * 新增记录
     * @param param
     * @return
     */
    FeishuCommonResponseDto addBitTableForRecords(AddRecordsParam param);


    /**
     * 新增多条记录
     * @param param
     * @return
     */
    FeishuCommonResponseDto batchAddBitTableForRecords(BatchAddRecordsParam param);


    /**
     * 更新记录
     * @param param
     * @return
     */
    FeishuCommonResponseDto updateBitTableForRecords(UpdateRecordsParam param);


    /**
     * 更新多条记录
     * @param param 111
     * @return 222
     */
    FeishuCommonResponseDto batchUpdateBitTableForRecords(BatchUpdateRecordsParam param);


    /**
     * 批量删除记录
     * @param param 111
     * @return 222
     */
    FeishuCommonResponseDto batchDeleteBitTableForRecords(BatchDeleteRecordsParam param);

    /**
     * 列出字段
     * @param param
     * @return
     */
    FeishuBitableResponseDto queryBitTableForFields(QueryFieldsParam param);


    /**
     * 新增字段
     * @param param
     * @return
     */
    FeishuCommonResponseDto addBitTableForFields(AddFieldsParam param);


    /**
     * 更新字段
     * @param param
     * @return
     */
    FeishuCommonResponseDto updateBitTableForFields(UpdateFieldsParam param);


    /**
     * 删除字段
     * @param param
     * @return
     */
    FeishuCommonResponseDto deleteBitTableForFields(UpdateFieldsParam param);
}

实现类：impl 层

package com.porton.feishuintegration.service.impl;

import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.util.ObjectUtil;
import cn.hutool.json.JSONUtil;
import com.porton.feishuintegration.enums.ViewsTypeEnum;
import com.porton.feishuintegration.model.common.FeishuCommonResponseDto;
import com.porton.feishuintegration.model.common.ResultResponse;
import com.porton.feishuintegration.model.feishuBitable.*;
import com.porton.feishuintegration.service.FeishuBitableService;
import com.porton.feishuintegration.service.FeishuCommonService;
import com.porton.feishuintegration.util.ToolUtil;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.http.*;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.web.client.RestTemplate;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import static com.porton.feishuintegration.exception.ErrorEnum.READONLY_ACCOUNT;


/**
 * 
 * 飞书多维表格服务实现类
 */
@Service
@Slf4j
public class FeishuBitablleServiceImpl implements FeishuBitableService {

    @Value("${feishu.bitable.get.url}")
    private String bitableBaseUrl;

    @Value("${feishu.robot.appId}")
    private String robotAppId;

    @Value("${feishu.robot.appSecret}")
    private String robotAppSecret;

    @Autowired
    private RestTemplate restTemplate;

    @Autowired
    private FeishuCommonService feishuCommonService;

//    @Override
//    public FeishuBitableResponseDto getAppData(String appToken) {
//
//        /:app_token/tables/:table_id/views
//        String url = bitableBaseUrl + appToken+"/tables"++"/views";
//        String token = feishuCommonService.getAppAccessToken(robotAppId, robotAppSecret);
//        HttpHeaders headers = new HttpHeaders();
//        headers.setBearerAuth(token);
//        HttpEntity<FeishuBitableResponseDto> response = restTemplate.exchange(url, HttpMethod.GET,
//                new HttpEntity<>(headers),FeishuBitableResponseDto.class);
//        FeishuBitableResponseDto resDto = response.getBody();
//        return resDto;
//    }

    @Override
    public FeishuBitableResponseDto getAppData(BitableTableIdParam param) {
        //url 拼接
        String url = bitableBaseUrl + param.getAppToken() + "/tables/" + param.getTableId() + "/views";
        //是否拼接分页参数
        if (ToolUtil.isNotEmpty(param.getPageSize())) {
            url = url + "?page_size=" + param.getPageSize();
        }
        if (ToolUtil.isNotEmpty(param.getPageToken())) {
            url = url + "&page_token=" + param.getPageToken();
        }
        //获取token,先判断前端传appid和secret，如果传了用传的，没有用默认的
        String token = getCommonToken(param.getAppId(), param.getAppSecret());

        HttpHeaders headers = new HttpHeaders();
        headers.setBearerAuth(token);
        //调用接口
        HttpEntity<FeishuBitableResponseDto> response = restTemplate.exchange(url, HttpMethod.GET,
                new HttpEntity<>(headers), FeishuBitableResponseDto.class);
        FeishuBitableResponseDto resDto = response.getBody();
        log.info("获取视图列表返回结果", response);
        return resDto;
    }


    /***
     * 列出视图接口
     * 要传app_token 和table_id
     * 查的是表格数据
     *
     * 第二层
     * @param param
     * @return
     */
    @Override
    public ResultResponse getAppTokentableIdAppData(BitableTableIdParam param) {
        //返回数据集
        List<FeishuBitableResponseDto> mapsList = new ArrayList<>();

        FeishuBitableResponseDto resDto = null;
        //调用接口返回数据
        HttpEntity<FeishuBitableResponseDto> response = null;

        //如果传app_token 和 table_id 的路径
        String url = bitableBaseUrl + param.getAppToken() + "/tables/" + param.getTableId() + "/views";

        //是否拼接分页参数
        if (ToolUtil.isNotEmpty(param.getPageSize())) {
            url = url + "?page_size=" + param.getPageSize();
        }
        if (ToolUtil.isNotEmpty(param.getPageToken())) {
            url = url + "&page_token=" + param.getPageToken();
        }
        //获取登录token
//        String token = feishuCommonService.getAppAccessToken(robotAppId, robotAppSecret);
        String token = getCommonToken(param.getAppId(), param.getAppSecret());
        HttpHeaders headers = new HttpHeaders();
        headers.setBearerAuth(token);

        try {
            //调用第三方接口
            response = restTemplate.exchange(url, HttpMethod.GET, new HttpEntity<>(headers), FeishuBitableResponseDto.class);
        } catch (Exception e) {
//            throw new BusinessException(FORBIDDEN_ACCOUNT.getCode(),FORBIDDEN_ACCOUNT.getDescription());
            return ResultResponse.failResponse(READONLY_ACCOUNT.getDescription());
        }

        if (ToolUtil.isNotEmpty(response)) {
            resDto = response.getBody();
        }

        //根据返回的值查第三层
        if (ObjectUtil.isNotEmpty(resDto) && resDto.getMsg().equals("success") && ObjectUtil.isNotEmpty(resDto.getData())) {
            Map<String, Object> data = resDto.getData();
            List<Map<String, Object>> items = (List<Map<String, Object>>) data.get("items");
            for (Map<String, Object> m : items) {
                //获取参数
                String view_id = (String) m.get("view_id");
                String view_type = (String) m.get("view_type");
                String view_name = (String) m.get("view_name");

                param.setViewId(view_id);
                //根据视图id，查询-明细数据，这是表格
                if (ObjectUtil.equal(view_type, "grid")) {
                    FeishuBitableResponseDto recordsAppData = getRecordsAppData(param);
                    recordsAppData.setViewName(view_name);
                    mapsList.add(recordsAppData);
                }
            }
        }
        log.info("调用视图返回结果----------------" + resDto);

        System.out.println("调用视图===========" + resDto);
        return ResultResponse.successResponse(mapsList);
    }


    /***
     * 获取多维表格
     * 表格级
     * 列出数据表
     * 第一层
     * @param param
     * @return
     */
    @Override
    public ResultResponse getAppTokenAppData(BitableAppTokenParam param) {

        List<FeishuBitableResponseDto> resDto = new ArrayList<>();
        //调用接口返回
        HttpEntity<FeishuBitableResponseDto> response = null;
        String url = bitableBaseUrl + param.getAppToken() + "/tables/";
        //是否拼接分页参数
        if (ToolUtil.isNotEmpty(param.getPageSize())) {
            url = url + "?page_size=" + param.getPageSize();
        }
        if (ToolUtil.isNotEmpty(param.getPageToken())) {
            url = url + "&page_token=" + param.getPageToken();
        }
        String token = getCommonToken(param.getAppId(), param.getAppSecret());
        HttpHeaders headers = new HttpHeaders();
        headers.setBearerAuth(token);
        try {
            response = restTemplate.exchange(url, HttpMethod.GET, new HttpEntity<>(headers), FeishuBitableResponseDto.class);

            if (ToolUtil.isNotEmpty(response)) {
                List<Map<String, Object>> items = (List<Map<String, Object>>) response.getBody().getData().get("items");
                for (Map<String, Object> m : items) {
                    //获取参数
                    String table_id = (String) m.get("table_id");
                    String name = (String) m.get("name");
                    BitableTableIdParam bitableTableIdParam = BeanUtil.copyProperties(param, BitableTableIdParam.class);

                    bitableTableIdParam.setTableId(table_id);
                    //根据视图id，查询-明细数据，这是表格
                    ResultResponse appTokentableIdAppData = getAppTokentableIdAppData(bitableTableIdParam);
                    if (ObjectUtil.equal(appTokentableIdAppData.getCode(), 200)) {
                        List<FeishuBitableResponseDto> data = (List<FeishuBitableResponseDto>) appTokentableIdAppData.getData();
                        for (FeishuBitableResponseDto dto : data) {
                            dto.setTableName(name);
                        }
                        resDto.addAll(data);
                    }
                }
            }
            return ResultResponse.successResponse(resDto);
        } catch (Exception e) {
            log.error("查询表格数据，异常：", e.getMessage());
            return ResultResponse.failResponse(READONLY_ACCOUNT.getDescription());
        }
    }


    /***
     * 获取多维表格
     * 单元格数据
     *
     * @param param
     * @return
     */
    @Override
    public FeishuBitableResponseDto getAppTokentableIdFormIdAppData(BitableFormIdParam param) {
        FeishuBitableResponseDto resDto = null;

        String url = bitableBaseUrl + param.getAppToken() + "/tables/" + param.getTableId() + "/forms/" + param.getFormId();

        //是否拼接分页参数
        if (ToolUtil.isNotEmpty(param.getPageSize())) {
            url = url + "?page_size=" + param.getPageSize();
        }
        if (ToolUtil.isNotEmpty(param.getPageToken())) {
            url = url + "&page_token=" + param.getPageToken();
        }
//        String token = feishuCommonService.getAppAccessToken(robotAppId, robotAppSecret);
        String token = getCommonToken(param.getAppId(), param.getAppSecret());
        HttpHeaders headers = new HttpHeaders();
        headers.setBearerAuth(token);
        HttpEntity<FeishuBitableResponseDto> response = restTemplate.exchange(url, HttpMethod.GET, new HttpEntity<>(headers), FeishuBitableResponseDto.class);
        if (ToolUtil.isNotEmpty(response)) {
            resDto = response.getBody();
        }
        return resDto;
    }


    /**
     * 获取多维表格
     * 列出记录
     * 明细数据
     * 第三层
     *
     * @param param
     * @return
     */
    @Override
    public FeishuBitableResponseDto getRecordsAppData(BitableTableIdParam param) {
        FeishuBitableResponseDto resDto = null;

        String url = bitableBaseUrl + param.getAppToken() + "/tables/" + param.getTableId() + "/records";

        //是否拼接分页参数
        if (ToolUtil.isNotEmpty(param.getViewId())) {
            url = url + "?view_id=" + param.getViewId();
        }
        if (ToolUtil.isNotEmpty(param.getPageSize())) {
            url = url + "&page_size=" + param.getPageSize();
        }
        if (ToolUtil.isNotEmpty(param.getPageToken())) {
            url = url + "&page_token=" + param.getPageToken();
        }
//        String token = feishuCommonService.getAppAccessToken(robotAppId, robotAppSecret);
        String token = getCommonToken(param.getAppId(), param.getAppSecret());
        HttpHeaders headers = new HttpHeaders();
        headers.setBearerAuth(token);
        HttpEntity<FeishuBitableResponseDto> response = restTemplate.exchange(url, HttpMethod.GET, new HttpEntity<>(headers), FeishuBitableResponseDto.class);
        if (ToolUtil.isNotEmpty(response)) {
            resDto = response.getBody();
        }
        return resDto;
    }


    /**
     * 递归查询
     * @param param
     * @return
     */
    @Override
    public FeishuBitableResponseDto getRecordsRecursionAppData(BitableTableIdParam param) {


        FeishuBitableResponseDto resDto = null;

        String url = bitableBaseUrl + param.getAppToken() + "/tables/" + param.getTableId() + "/records";

        //是否拼接分页参数
        if (ToolUtil.isNotEmpty(param.getViewId())) {
            url = url + "?view_id=" + param.getViewId();
        }
        if (ToolUtil.isNotEmpty(param.getPageSize())) {
            url = url + "&page_size=" + param.getPageSize();
        }
        if (ToolUtil.isNotEmpty(param.getPageToken())) {
            url = url + "&page_token=" + param.getPageToken();
        }

//        String token = feishuCommonService.getAppAccessToken(robotAppId, robotAppSecret);
        String token = getCommonToken(param.getAppId(), param.getAppSecret());
        HttpHeaders headers = new HttpHeaders();
        headers.setBearerAuth(token);
        HttpEntity<FeishuBitableResponseDto> response = restTemplate.exchange(url, HttpMethod.GET, new HttpEntity<>(headers), FeishuBitableResponseDto.class);
        if (ToolUtil.isNotEmpty(response)) {
            resDto = response.getBody();

        }
        return resDto;
    }

    /***
     * 新增数据表
     * @param param
     * @return
     */
    @Override
    public FeishuCommonResponseDto addBitTableForName(AddTableIdParam param) {
        //返回信息
        FeishuCommonResponseDto resDto = new FeishuCommonResponseDto();
        //接口返回
        HttpEntity<FeishuCommonResponseDto> response = null;
        String url = bitableBaseUrl + param.getAppToken() + "/tables";
        //获取token
        String token = getCommonToken(param.getAppId(), param.getAppSecret());
        HttpHeaders headers = new HttpHeaders();
        headers.setBearerAuth(token);
        //传参
        Map<String, Object> hashMap = new HashMap<>();
        hashMap.put("table", param.getTable());
        //请求体
        RequestEntity<String> requestEntity = RequestEntity
                .post(url)
                .headers(headers)
                .contentType(MediaType.APPLICATION_JSON)
                .body(JSONUtil.toJsonStr(hashMap)); //也可以是DTO
        try {
            response = restTemplate.exchange(requestEntity, FeishuCommonResponseDto.class);

            if (ToolUtil.isNotEmpty(response)) {
                resDto = response.getBody();
            }
            return resDto;
        } catch (Exception e) {
            log.info("新增表格，错误信息" + e.getMessage());
            resDto.setCode(400);
            if (e.getMessage().contains("1254000") || e.getMessage().contains("1254001")) {
                resDto.setMsg("请求体错误");
            } else if (e.getMessage().contains("1254013")) {
                resDto.setMsg("表名重复");
            }
            return resDto;
        }

    }


    /***
     * 批量新增数据表
     * @param param
     * @return
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public FeishuCommonResponseDto BatchAddBitTableForNames(BatchAddTableIdParam param) {
        FeishuCommonResponseDto resDto = new FeishuCommonResponseDto();
        HttpEntity<FeishuCommonResponseDto> response = null;
        //判断是否有相同元素
        List<TableNameEntry> tableEntries = param.getTables();
        Integer priCount = tableEntries.size();   //集合的长度
        Long nextCount = tableEntries.stream().distinct().count();   //经过处理之后的集合长度
        if (!ObjectUtil.equal(priCount, nextCount.intValue())) {
            resDto.setCode(400);
            resDto.setMsg("有重复的表格名称");
            return resDto;
        }

        String url = bitableBaseUrl + param.getAppToken() + "/tables/batch_create";
        //获取token
        String token = getCommonToken(param.getAppId(), param.getAppSecret());
        HttpHeaders headers = new HttpHeaders();
        headers.setBearerAuth(token);

        Map<String, Object> hashMap = new HashMap<>();
        hashMap.put("tables", JSONUtil.parseArray(param.getTables()));

        //请求体
        RequestEntity<String> requestEntity = RequestEntity
                .post(url)
                .headers(headers)
                .contentType(MediaType.APPLICATION_JSON)
                .body(JSONUtil.toJsonStr(hashMap)); //也可以是DTO
        try {
            response = restTemplate.exchange(requestEntity, FeishuCommonResponseDto.class);
            if (ToolUtil.isNotEmpty(response)) {
                resDto = response.getBody();
            }
            return resDto;
        } catch (Exception e) {
            log.info("批量新增表格错误信息" + e.getMessage());
            resDto.setCode(400);
            if (e.getMessage().contains("1254000") || e.getMessage().contains("1254001")) {
                resDto.setMsg("请求体错误");
            } else if (e.getMessage().contains("1254013")) {
                resDto.setMsg("表名重复");
            }
            return resDto;
        }

    }


    /***
     * 新建视图
     * @param param
     * @return
     */
    @Override
    @Transactional(rollbackFor = Exception.class)
    public FeishuCommonResponseDto AddBitTableForViews(AddTableIdViewsParam param) {

        FeishuCommonResponseDto resDto = new FeishuCommonResponseDto();
        HttpEntity<FeishuCommonResponseDto> response = null;
        //视图枚举
        List<ViewsTypeEnum> allEnum = ViewsTypeEnum.getAllEnum();
        //视图类型集合
        List<String> arrayList = new ArrayList<>();
        for (ViewsTypeEnum typeEnum : allEnum) {
            arrayList.add(typeEnum.getDescription());
        }
        if (!arrayList.contains(param.getViews().getView_type())) {
            resDto.setCode(400);
            resDto.setMsg("视图类型错误，正确的视图类型如下：" + arrayList.toString());
            return resDto;
        }
        String url = bitableBaseUrl + param.getAppToken() + "/tables/" + param.getTableId() + "/views";
        //获取token
        String token = getCommonToken(param.getAppId(), param.getAppSecret());
        HttpHeaders headers = new HttpHeaders();
        headers.setBearerAuth(token);

        //请求体
        RequestEntity<String> requestEntity = RequestEntity
                .post(url)
                .headers(headers)
                .contentType(MediaType.APPLICATION_JSON)
                .body(JSONUtil.toJsonStr(param.getViews())); //也可以是DTO
        try {
            response = restTemplate.exchange(requestEntity, FeishuCommonResponseDto.class);
            if (ToolUtil.isNotEmpty(response)) {
                resDto = response.getBody();
            }
            return resDto;
        } catch (Exception e) {
            log.info("新增视图错误信息" + e.getMessage());
            resDto.setCode(400);
            if (e.getMessage().contains("1254000") || e.getMessage().contains("1254001")) {
                resDto.setMsg("请求体错误");
            } else if (e.getMessage().contains("1254020")) {
                resDto.setMsg("视图名重复");
            } else if (e.getMessage().contains("1254021")) {
                resDto.setMsg("视图名为空");
            }
            return resDto;
        }
    }


    /**
     * 删除视图
     *
     * @param param
     * @return
     */
    @Override
    public FeishuCommonResponseDto deleteBitTableForViews(AddTableIdViewsParam param) {
        FeishuCommonResponseDto resDto = new FeishuCommonResponseDto();
        HttpEntity<FeishuCommonResponseDto> response = null;

        String url = bitableBaseUrl + param.getAppToken() + "/tables/" + param.getTableId() + "/views" + param.getViewId();
        //获取token
        String token = getCommonToken(param.getAppId(), param.getAppSecret());
        HttpHeaders headers = new HttpHeaders();
        headers.setBearerAuth(token);

        try {
            // 使用exchange发送DELETE请求
            response = restTemplate.exchange(url, HttpMethod.DELETE, null, FeishuCommonResponseDto.class);
            if (ToolUtil.isNotEmpty(response)) {
                resDto = response.getBody();
            }
            return resDto;
        } catch (Exception e) {
            log.info("删除视图错误信息" + e.getMessage());
            resDto.setCode(400);

            //可以建枚举优化
            if (e.getMessage().contains("1254000") || e.getMessage().contains("1254001")) {
                resDto.setMsg("请求体错误");
            } else if (e.getMessage().contains("1254023")) {
                resDto.setMsg("最后一个视图禁止删除");
            }
            return resDto;
        }
    }


    /**
     * 新增记录
     *
     * @param param
     * @return
     */
    @Override
    public FeishuCommonResponseDto addBitTableForRecords(AddRecordsParam param) {
        FeishuCommonResponseDto resDto = new FeishuCommonResponseDto();
        HttpEntity<FeishuCommonResponseDto> response = null;
        //路径
        String url = bitableBaseUrl + param.getAppToken() + "/tables/" + param.getTableId() + "/records?user_id_type=user_id";
        //获取token
        String token = getCommonToken(param.getAppId(), param.getAppSecret());
        HttpHeaders headers = new HttpHeaders();
        headers.setBearerAuth(token);

        Map<String, Object> hashMap = new HashMap<>();
        //这里还要在json转换一次
        hashMap.put("fields", param.getFields());
        //请求体
        RequestEntity<String> requestEntity = RequestEntity
                .post(url)
                .headers(headers)
                .contentType(MediaType.APPLICATION_JSON)
                .body(JSONUtil.toJsonStr(hashMap)); //也可以是DTO
        try {
            response = restTemplate.exchange(requestEntity, FeishuCommonResponseDto.class);
            if (ToolUtil.isNotEmpty(response)) {
                resDto = response.getBody();
            }
            return resDto;
        } catch (Exception e) {
            log.info("新增记录错误信息" + e.getMessage());
            resDto.setCode(400);

            //可以建枚举优化
            if (e.getMessage().contains("1254000") || e.getMessage().contains("1254001")) {
                resDto.setMsg("请求体错误");
            } else if (e.getMessage().contains("1254007")) {
                resDto.setMsg("空值");
            } else if (e.getMessage().contains("1254045")) {
                resDto.setMsg("字段名字不存在");
            } else if (e.getMessage().contains("1254103")) {
                resDto.setMsg("记录数量超限, 限制20,000条");
            } else if (e.getMessage().contains("1254004")) {
                resDto.setMsg("table_id 错误");
            }

            return resDto;
        }
    }

    /**
     * 新增多条记录
     *
     * @param param
     * @return
     */
    @Override
    public FeishuCommonResponseDto batchAddBitTableForRecords(BatchAddRecordsParam param) {
        FeishuCommonResponseDto resDto = new FeishuCommonResponseDto();
        HttpEntity<FeishuCommonResponseDto> response = null;

        String url = bitableBaseUrl + param.getAppToken() + "/tables/" + param.getTableId() + "/records/batch_create";
        //获取token
        String token = feishuCommonService.getAppAccessToken(param.getAppId(), param.getAppSecret());
        HttpHeaders headers = new HttpHeaders();
        headers.setBearerAuth(token);


        Map<String, Object> hashMap = new HashMap<>();
        hashMap.put("records", JSONUtil.parseArray(param.getRecords()));

        //请求体
        RequestEntity<String> requestEntity = RequestEntity
                .post(url)
                .headers(headers)
                .contentType(MediaType.APPLICATION_JSON)
                .body(JSONUtil.toJsonStr(hashMap)); //也可以是DTO
        try {
            response = restTemplate.exchange(requestEntity, FeishuCommonResponseDto.class);
            if (ToolUtil.isNotEmpty(response)) {
                resDto = response.getBody();
            }
            return resDto;
        } catch (Exception e) {
            log.info("新增多条记录错误信息" + e.getMessage());
            resDto.setCode(400);

            //可以建枚举优化
            if (e.getMessage().contains("1254000") || e.getMessage().contains("1254001")) {
                resDto.setMsg("请求体错误");
            } else if (e.getMessage().contains("1254007")) {
                resDto.setMsg("空值");
            } else if (e.getMessage().contains("1254045")) {
                resDto.setMsg("字段名字不存在");
            } else if (e.getMessage().contains("1254103")) {
                resDto.setMsg("记录数量超限, 限制20,000条");
            } else if (e.getMessage().contains("1254004")) {
                resDto.setMsg("table_id 错误");
            }
            return resDto;
        }
    }

    /**
     * 更新记录
     *
     * @param param
     * @return
     */
    @Override
    public FeishuCommonResponseDto updateBitTableForRecords(UpdateRecordsParam param) {
        FeishuCommonResponseDto resDto = new FeishuCommonResponseDto();
        HttpEntity<FeishuCommonResponseDto> response = null;

        String url = bitableBaseUrl + param.getAppToken() + "/tables/" + param.getTableId() + "/records/" + param.getRecordId() + "?user_id_type=user_id";
        //获取token
        String token = getCommonToken(param.getAppId(), param.getAppSecret());
        HttpHeaders headers = new HttpHeaders();
        headers.setBearerAuth(token);

        Map<String, Object> hashMap = new HashMap<>();
        hashMap.put("fields", param.getFields());

        //请求体
        RequestEntity<String> requestEntity = RequestEntity
                .put(url)
                .headers(headers)
                .contentType(MediaType.APPLICATION_JSON)
                .body(JSONUtil.toJsonStr(hashMap)); //也可以是DTO
        try {
            response = restTemplate.exchange(requestEntity, FeishuCommonResponseDto.class);
            if (ToolUtil.isNotEmpty(response)) {
                resDto = response.getBody();
            }
            return resDto;
        } catch (Exception e) {
            log.info("更新记录错误信息" + e.getMessage());
            resDto.setCode(400);

            //可以建枚举优化
            if (e.getMessage().contains("1254000") || e.getMessage().contains("1254001")) {
                resDto.setMsg("请求体错误");
            } else if (e.getMessage().contains("1254007")) {
                resDto.setMsg("空值");
            } else if (e.getMessage().contains("1254045")) {
                resDto.setMsg("字段名字不存在");
            } else if (e.getMessage().contains("1254006")) {
                resDto.setMsg("检查 record_id");
            } else if (e.getMessage().contains("1254043")) {
                resDto.setMsg("record_id 不存在");
            }
            return resDto;
        }
    }

    /**
     * 更新多条记录
     *
     * @param param
     * @return
     */
    @Override
    public FeishuCommonResponseDto batchUpdateBitTableForRecords(BatchUpdateRecordsParam param) {
        FeishuCommonResponseDto resDto = new FeishuCommonResponseDto();
        HttpEntity<FeishuCommonResponseDto> response = null;
        //路径
        String url = bitableBaseUrl + param.getAppToken() + "/tables/" + param.getTableId() + "/records/batch_update";
        //获取token
        String token = getCommonToken(param.getAppId(), param.getAppSecret());
        HttpHeaders headers = new HttpHeaders();
        headers.setBearerAuth(token);

        Map<String, Object> hashMap = new HashMap<>();
        hashMap.put("records", JSONUtil.parseArray(param.getRecords()));

        //请求体
        RequestEntity<String> requestEntity = RequestEntity
                .post(url)
                .headers(headers)
                .contentType(MediaType.APPLICATION_JSON)
                .body(JSONUtil.toJsonStr(hashMap)); //也可以是DTO
        try {
            response = restTemplate.exchange(requestEntity, FeishuCommonResponseDto.class);
            if (ToolUtil.isNotEmpty(response)) {
                resDto = response.getBody();
            }
            return resDto;
        } catch (Exception e) {
            log.info("更新多条记录错误信息" + e.getMessage());
            resDto.setCode(400);
            //可以建枚举优化
            if (e.getMessage().contains("1254000") || e.getMessage().contains("1254001")) {
                resDto.setMsg("请求体错误");
            } else if (e.getMessage().contains("1254007")) {
                resDto.setMsg("空值");
            } else if (e.getMessage().contains("1254045")) {
                resDto.setMsg("字段名字不存在");
            } else if (e.getMessage().contains("1254006")) {
                resDto.setMsg("检查 record_id");
            } else if (e.getMessage().contains("1254043")) {
                resDto.setMsg("record_id 不存在");
            }
            return resDto;
        }
    }

    @Override
    public FeishuCommonResponseDto batchDeleteBitTableForRecords(BatchDeleteRecordsParam param) {
        FeishuCommonResponseDto resDto = new FeishuCommonResponseDto();
        if (param.getRecords().size() > 0) {
            HttpEntity<FeishuCommonResponseDto> response = null;
            //路径
            String url = bitableBaseUrl + param.getAppToken() + "/tables/" + param.getTableId() + "/records/batch_delete";
            //获取token
            String token = getCommonToken(param.getAppId(), param.getAppSecret());
            HttpHeaders headers = new HttpHeaders();
            headers.setBearerAuth(token);

            Map<String, Object> hashMap = new HashMap<>();
            hashMap.put("records", JSONUtil.parseArray(param.getRecords()));
//请求体
            RequestEntity<String> requestEntity = RequestEntity
                    .post(url)
                    .headers(headers)
                    .contentType(MediaType.APPLICATION_JSON)
                    .body(JSONUtil.toJsonStr(hashMap)); //也可以是DTO
            try {
                response = restTemplate.exchange(requestEntity, FeishuCommonResponseDto.class);
                if (ToolUtil.isNotEmpty(response)) {
                    resDto = response.getBody();
                }
                return resDto;
            } catch (Exception e) {
                log.error("删除多条记录错误信息" + e.getMessage());
                resDto.setCode(400);
                return resDto;
            }
        } else {
            return resDto;
        }
    }

    /**
     * 列出字段
     *
     * @param param
     * @return
     */
    @Override
    public FeishuBitableResponseDto queryBitTableForFields(QueryFieldsParam param) {
        FeishuBitableResponseDto resDto = new FeishuBitableResponseDto();
        //路径
        String url = bitableBaseUrl + param.getAppToken() + "/tables/" + param.getTableId() + "/fields";
        //获取token
        String token = getCommonToken(param.getAppId(), param.getAppSecret());

        HttpHeaders headers = new HttpHeaders();
        headers.setBearerAuth(token);

        //是否拼接分页参数
        if (ToolUtil.isNotEmpty(param.getPageSize())) {
            url = url + "?page_size=" + param.getPageSize();
        }
        if (ToolUtil.isNotEmpty(param.getPageToken())) {
            url = url + "&page_token=" + param.getPageToken();
        }
        if (ToolUtil.isNotEmpty(param.getTextFieldAsArray())) {
            url = url + "&text_field_as_array=" + param.getTextFieldAsArray();
        }
        if (ToolUtil.isNotEmpty(param.getViewId())) {
            url = url + "&view_id=" + param.getViewId();
        }

        HttpEntity<FeishuBitableResponseDto> response = restTemplate.exchange(url, HttpMethod.GET, new HttpEntity<>(headers), FeishuBitableResponseDto.class);
        if (ToolUtil.isNotEmpty(response)) {
            resDto = response.getBody();
        }

        return resDto;
    }

    /**
     * 新增字段
     *
     * @param param
     * @return
     */
    @Override
    public FeishuCommonResponseDto addBitTableForFields(AddFieldsParam param) {
        FeishuCommonResponseDto resDto = new FeishuCommonResponseDto();
        HttpEntity<FeishuCommonResponseDto> response = null;
        //路径
        String url = bitableBaseUrl + param.getAppToken() + "/tables/" + param.getTableId() + "/fields";
        //获取token
        String token = getCommonToken(param.getAppId(), param.getAppSecret());
        HttpHeaders headers = new HttpHeaders();
        headers.setBearerAuth(token);

        Map<String, Object> hashMap = new HashMap<>();
        hashMap.put("field_name", param.getField_name());
        hashMap.put("type", param.getType());

        //请求体
        RequestEntity<String> requestEntity = RequestEntity
                .post(url)
                .headers(headers)
                .contentType(MediaType.APPLICATION_JSON)
                .body(JSONUtil.toJsonStr(hashMap)); //也可以是DTO
        try {
            response = restTemplate.exchange(requestEntity, FeishuCommonResponseDto.class);
            if (ToolUtil.isNotEmpty(response)) {
                resDto = response.getBody();
            }
            return resDto;
        } catch (Exception e) {
            log.info("新增字段错误信息" + e.getMessage());
            resDto.setCode(400);

            //可以建枚举优化
            if (e.getMessage().contains("1254000") || e.getMessage().contains("1254001")) {
                resDto.setMsg("请求体错误");
            } else if (e.getMessage().contains("1254007")) {
                resDto.setMsg("空值");
            } else if (e.getMessage().contains("1254045")) {
                resDto.setMsg("字段名字不存在");
            } else if (e.getMessage().contains("1254103")) {
                resDto.setMsg("记录数量超限, 限制20,000条");
            } else if (e.getMessage().contains("1254004")) {
                resDto.setMsg("table_id 错误");
            }
            return resDto;
        }
    }


    /**
     * 更新字段
     *
     * @param param
     * @return
     */
    @Override
    public FeishuCommonResponseDto updateBitTableForFields(UpdateFieldsParam param) {
        FeishuCommonResponseDto resDto = new FeishuCommonResponseDto();
        HttpEntity<FeishuCommonResponseDto> response = null;
        //路径
        String url = bitableBaseUrl + param.getAppToken() + "/tables/" + param.getTableId() + "/fields" + param.getFieldId();
        //获取token
        String token = getCommonToken(param.getAppId(), param.getAppSecret());
        HttpHeaders headers = new HttpHeaders();
        headers.setBearerAuth(token);

        Map<String, Object> hashMap = new HashMap<>();
        hashMap.put("field_name", param.getField_name());
        hashMap.put("type", param.getType());

        String jsonObj = JSONUtil.toJsonStr(hashMap);

        HttpEntity<String> httpEntity = new HttpEntity(jsonObj, headers);
        //请求体
        RequestEntity<String> requestEntity = RequestEntity
                .put(url)
                .headers(headers)
                .contentType(MediaType.APPLICATION_JSON)
                .body(JSONUtil.toJsonStr(hashMap)); //也可以是DTO
        try {
            restTemplate.put(url, httpEntity);
            if (ToolUtil.isNotEmpty(response)) {
                resDto = response.getBody();
            }
            return resDto;
        } catch (Exception e) {
            log.info("更新字段错误信息" + e.getMessage());
            resDto.setCode(400);

            //可以建枚举优化
            if (e.getMessage().contains("1254000") || e.getMessage().contains("1254001")) {
                resDto.setMsg("请求体错误");
            } else if (e.getMessage().contains("1254007")) {
                resDto.setMsg("空值");
            } else if (e.getMessage().contains("1254045")) {
                resDto.setMsg("字段名字不存在");
            } else if (e.getMessage().contains("1254103")) {
                resDto.setMsg("记录数量超限, 限制20,000条");
            } else if (e.getMessage().contains("1254004")) {
                resDto.setMsg("table_id 错误");
            }
            return resDto;
        }
    }


    /**
     * 删除字段
     *
     * @param param
     * @return
     */
    @Override
    public FeishuCommonResponseDto deleteBitTableForFields(UpdateFieldsParam param) {
        FeishuCommonResponseDto resDto = new FeishuCommonResponseDto();
        HttpEntity<FeishuCommonResponseDto> response = null;
        //路径
        String url = bitableBaseUrl + param.getAppToken() + "/tables/" + param.getTableId() + "/fields" + param.getFieldId();
        //获取token
        String token = getCommonToken(param.getAppId(), param.getAppSecret());
        HttpHeaders headers = new HttpHeaders();
        headers.setBearerAuth(token);

        try {
            // 使用exchange发送DELETE请求
            response = restTemplate.exchange(url, HttpMethod.DELETE, null, FeishuCommonResponseDto.class);
            if (ToolUtil.isNotEmpty(response)) {
                resDto = response.getBody();
            }
            return resDto;
        } catch (Exception e) {
            log.info("删除字段错误信息" + e.getMessage());
            resDto.setCode(400);

            //可以建枚举优化
            if (e.getMessage().contains("1254000") || e.getMessage().contains("1254001")) {
                resDto.setMsg("请求体错误");
            } else if (e.getMessage().contains("1254007")) {
                resDto.setMsg("空值");
            } else if (e.getMessage().contains("1254045")) {
                resDto.setMsg("字段名字不存在");
            } else if (e.getMessage().contains("1254103")) {
                resDto.setMsg("记录数量超限, 限制20,000条");
            } else if (e.getMessage().contains("1254004")) {
                resDto.setMsg("table_id 错误");
            }
            return resDto;
        }
    }


    public String getCommonToken(String appid, String appSecret) {

        String token = null;

        if (ObjectUtil.isNotEmpty(appid) && ObjectUtil.isNotEmpty(appSecret)) {
            token = feishuCommonService.getAppAccessToken(appid, appSecret);
        } else {
            token = feishuCommonService.getAppAccessToken(robotAppId, robotAppSecret);
        }

        return token;
    }
}