FeiShuApiService.java

package com.pipihelper.project.feishu.service;

import com.alibaba.fastjson.JSON;
import com.alibaba.fastjson.JSONObject;
import com.alibaba.fastjson.TypeReference;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.github.benmanes.caffeine.cache.Cache;
import com.github.benmanes.caffeine.cache.Caffeine;
import com.pipihelper.project.core.ServiceException;
import com.pipihelper.project.feishu.dto.FeiShuConfig;
import com.pipihelper.project.feishu.dto.FeiShuCreateTaskDTO;
import com.pipihelper.project.feishu.dto.FeiShuResultDTO;
import com.pipihelper.project.feishu.dto.chat.FeiShuChatDTO;
import com.pipihelper.project.feishu.dto.department.FeiShuDepartmentDTO;
import com.pipihelper.project.feishu.dto.doc.DocDTO;
import com.pipihelper.project.feishu.dto.doc.FieldsDTO;
import com.pipihelper.project.feishu.dto.employee.FeiShuEmployeeDTO;
import com.pipihelper.project.feishu.dto.msg.FeiShuBatchMsgDTO;
import com.pipihelper.project.feishu.dto.msg.FeiShuMsgDTO;
//import org.springframework.http.MediaType;
import lombok.extern.slf4j.Slf4j;
import okhttp3.*;
import org.apache.commons.lang3.StringUtils;
import org.springframework.http.HttpEntity;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpMethod;
import org.springframework.http.ResponseEntity;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
import org.springframework.util.LinkedMultiValueMap;
import org.springframework.util.MultiValueMap;
import org.springframework.web.client.RestTemplate;

import javax.annotation.Resource;
import java.lang.reflect.Type;
import java.time.Duration;
import java.util.ArrayList;
import java.util.List;

/**
 * @Description: TODO
 * @author: charles
 * @date: 2022年05月19日 15:40
 */
@Service
@Transactional
@Slf4j
public class FeiShuApiService {
    @Resource
    private FeiShuConfig feiShuConfig;


    private static ObjectMapper objectMapper = new ObjectMapper();


    private final Cache<Object, String> FEISHU_CACHE = Caffeine.newBuilder()
            .maximumSize(100)
            .expireAfterWrite(Duration.ofHours(2))
            .build();

    private final Cache<String, List<FeiShuEmployeeDTO>> EMPLOYEE_LIST_CACHE = Caffeine.newBuilder()
            .maximumSize(100)
            .expireAfterWrite(Duration.ofHours(2))
            .build();

    public String getTenantToken(String appName) {
        return FEISHU_CACHE.get("tenantAccessToken" + appName, key -> setTenantAccessToken(appName));
    }

    public String setTenantAccessToken(String appName) {
        String api = "/auth/v3/tenant_access_token/internal";
        RestTemplate restTemplate = new RestTemplate();
        JSONObject params = new JSONObject();
        params.put("app_id", feiShuConfig.getAppConfigMap().get(appName).getAppId());
        params.put("app_secret", feiShuConfig.getAppConfigMap().get(appName).getAppSecret());
        ResponseEntity<JSONObject> responseEntity = restTemplate.postForEntity(feiShuConfig.getFeiShuOpenApiHost() + api, params, JSONObject.class);
        System.out.println(responseEntity.getBody().get("tenant_access_token").toString());
        return responseEntity.getBody().get("tenant_access_token").toString();
    }

    /**
     * @param /https://open.feishu.cn/document/uAjLw4CM/ukTMukTMukTM/reference/im-v1/message/create
     * @param sendMsg
     * @return
     */
    public JSONObject sendMsg(Integer businessType, String receive_id_type, JSONObject sendMsg, String appName) {
        System.out.println(sendMsg.toString());

        //发送消息
        String api = "/im/v1/messages?receive_id_type={receive_id_type}";
        RestTemplate restTemplate = new RestTemplate();
        HttpHeaders headers = new HttpHeaders();
        headers.set("Authorization", "Bearer " + getTenantToken(appName));
        headers.set("Content-Type", "application/json; charset=utf-8");
        HttpEntity<String> requestEntity = new HttpEntity<>(sendMsg.toString(), headers);
        String url = feiShuConfig.getFeiShuOpenApiHost() + api;
        try {
            ResponseEntity<JSONObject> responseEntity = restTemplate.postForEntity(url, requestEntity, JSONObject.class, receive_id_type);
            if (responseEntity.getBody().getJSONObject("data") == null) {
                return null;
            }
            log.info("业务类型：{} ，消息发送成功，接收人： {}", businessType, sendMsg.getString("receive_id"));
            return responseEntity.getBody();
        } catch (Exception e) {
            log.error("飞书：" + api + "接口调用失败" + "\n" + e);
            throw new ServiceException("飞书：" + api + "接口调用失败" + "\n" + e);
        }
    }



    @Async
    public JSONObject replyMsg(String message_id, JSONObject replyMsg, String appName) {
        System.out.println(replyMsg.toString());
        String api = "/im/v1/messages/{message_id}/reply";
        RestTemplate restTemplate = new RestTemplate();
        HttpHeaders headers = new HttpHeaders();
        headers.set("Authorization", "Bearer " + getTenantToken(appName));
        headers.set("Content-Type", "application/json; charset=utf-8");
        HttpEntity<String> requestEntity = new HttpEntity<>(replyMsg.toString(), headers);
        String url = feiShuConfig.getFeiShuOpenApiHost() + api;
        try {
            ResponseEntity<JSONObject> responseEntity = restTemplate.postForEntity(url, requestEntity, JSONObject.class, message_id);
            log.info("飞书接口 {} 调用成功，返回值：{}", api, responseEntity.getBody());
            return responseEntity.getBody();
        } catch (Exception e) {
            throw new ServiceException("飞书：" + api + "接口调用失败" + "\n" + e);
        }
    }

    @Async
    public JSONObject patchMsg(String message_id, JSONObject content, String appName) {
        String api = "/im/v1/messages/";
        OkHttpClient client = new OkHttpClient();
        String url = feiShuConfig.getFeiShuOpenApiHost() + api;
        RequestBody requestBody = RequestBody.create(content.toString(), MediaType.parse("application/json"));
        Request request = new Request.Builder()
                .patch(requestBody)
                .url(url + message_id)
                .addHeader("Authorization", "Bearer " + getTenantToken(appName))
                .addHeader("Content-Type", "application/json; charset=utf-8")
                .build();
        try {
            Response response = client.newCall(request).execute();
            String responseString = response.body().string();
            log.info("飞书接口 {} 调用成功，返回值：{}", api, responseString);
            return JSONObject.parseObject(responseString);
        } catch (Exception e) {
            throw new ServiceException("飞书：" + api + "接口调用失败" + "\n" + e);
        }
    }

    @Async
    public JSONObject patchUrgentApp(String message_id, JSONObject content, String appName) {
        String api = "/im/v1/messages/" + message_id + "/urgent_sms?user_id_type=open_id";
        OkHttpClient client = new OkHttpClient();
        String url = feiShuConfig.getFeiShuOpenApiHost() + api;
        RequestBody requestBody = RequestBody.create(content.toString(), MediaType.parse("application/json"));
        Request request = new Request.Builder()
                .patch(requestBody)
                .url(url)
                .addHeader("Authorization", "Bearer " + getTenantToken(appName))
                .addHeader("Content-Type", "application/json; charset=utf-8")
                .build();
        try {
            Response response = client.newCall(request).execute();
            String responseString = response.body().string();
            System.out.println(responseString);
            return JSONObject.parseObject(responseString);
        } catch (Exception e) {
            System.out.println("飞书：" + api + "接口调用失败" + "\n" + e);
            return null;
        }
    }


    @Async
    public JSONObject patchUrgentSms(String message_id, JSONObject content, String appName) {
        String api = "/im/v1/messages/" + message_id + "/urgent_app?user_id_type=open_id";
        OkHttpClient client = new OkHttpClient();
        String url = feiShuConfig.getFeiShuOpenApiHost() + api;
        RequestBody requestBody = RequestBody.create(content.toString(), MediaType.parse("application/json"));
        Request request = new Request.Builder()
                .patch(requestBody)
                .url(url)
                .addHeader("Authorization", "Bearer " + getTenantToken(appName))
                .addHeader("Content-Type", "application/json; charset=utf-8")
                .build();
        try {
            Response response = client.newCall(request).execute();
            String responseString = response.body().string();
            System.out.println(responseString);
            return JSONObject.parseObject(responseString);
        } catch (Exception e) {
            System.out.println("飞书：" + api + "接口调用失败" + "\n" + e);
            return null;
        }
    }


    //    @Async
    public String createTask(FeiShuCreateTaskDTO taskMsg, String openId, String appName) {
        log.info("调用创建任务接口，task: {}", taskMsg.toString());
        String api = "/task/v1/tasks";
        RestTemplate restTemplate = new RestTemplate();
        HttpHeaders headers = new HttpHeaders();
        headers.set("Authorization", "Bearer " + getTenantToken(appName));
//        headers.set("Authorization", "Bearer " + "t-d3db00058d854b3c004ffdf6453fd3e169c82043");

        headers.set("Content-Type", "application/json; charset=utf-8");
        HttpEntity<String> requestEntity = new HttpEntity<>(JSON.toJSONString(taskMsg), headers);
        String url = feiShuConfig.getFeiShuOpenApiHost() + api;
//        String url = "https://open.feishu.cn/open-apis" + api;
        try {
            ResponseEntity<JSONObject> responseEntity = restTemplate.postForEntity(url, requestEntity, JSONObject.class);
            String taskId = responseEntity.getBody().getJSONObject("data").getJSONObject("task").getString("id");
            collaborators(taskId, openId, appName);
            return taskId;
        } catch (Exception e) {
            throw new ServiceException("飞书：" + api + "接口调用失败" + "\n" + e);
        }
    }


    public JSONObject collaborators(String taskId, String openId, String appName) {
        if (StringUtils.isBlank(openId)) {
            return null;
        }
        String api = "/task/v1/tasks/{taskId}/collaborators";
        RestTemplate restTemplate = new RestTemplate();
        JSONObject param = new JSONObject();
        param.put("id", openId);
        HttpHeaders headers = new HttpHeaders();
        headers.set("Authorization", "Bearer " + getTenantToken(appName));
        headers.set("Content-Type", "application/json; charset=utf-8");
        HttpEntity<String> requestEntity = new HttpEntity<>(param.toString(), headers);
        String url = feiShuConfig.getFeiShuOpenApiHost() + api;
        try {
            ResponseEntity<JSONObject> responseEntity = restTemplate.postForEntity(url, requestEntity, JSONObject.class, taskId);
            return responseEntity.getBody();
        } catch (Exception e) {
            throw new ServiceException("飞书：" + api + "接口调用失败" + "\n" + e);
        }
    }


    public byte[] getMessageFile(String messageId, String fileKey, String type, String appName) {
        String api = "/im/v1/messages/{messageId}/resources/{fileKey}/?type={type}";
        RestTemplate restTemplate = new RestTemplate();
        HttpHeaders headers = new HttpHeaders();
        headers.set("Authorization", "Bearer " + getTenantToken(appName));
        HttpEntity<MultiValueMap<String, Object>> requestEntity = new HttpEntity<>(headers);
        String url = feiShuConfig.getFeiShuOpenApiHost() + api;
        try {
            ResponseEntity<byte[]> responseEntity = restTemplate.exchange(url, HttpMethod.GET, requestEntity, byte[].class, messageId, fileKey, type);
            return responseEntity.getBody();
        } catch (Exception e) {
            throw new ServiceException("飞书：" + api + "接口调用失败");
        }
    }

    //获取指定部门下的员工信息
    public JSONObject getUser(String department_id, String appName) {
        String api = "/contact/v3/users/find_by_department?department_id={department_id}";
        RestTemplate restTemplate = new RestTemplate();
        HttpHeaders headers = new HttpHeaders();
        headers.set("Authorization", "Bearer " + getTenantToken(appName));
        headers.set("Content-Type", "application/json; charset=utf-8");
        HttpEntity<String> requestEntity = new HttpEntity<>(headers);
        String url = feiShuConfig.getFeiShuOpenApiHost() + api;
        try {
            ResponseEntity<JSONObject> responseEntity = restTemplate.exchange(url, HttpMethod.GET, requestEntity, JSONObject.class, department_id);
            return responseEntity.getBody();
        } catch (Exception e) {
            throw new ServiceException("飞书：" + api + "接口调用失败" + "\n" + e);
        }
    }

    //下载文件
    public byte[] downloadFile(String filePath, String appName) {
        String api = "/im/v1/files/{filePath}";
        RestTemplate restTemplate = new RestTemplate();
        HttpHeaders headers = new HttpHeaders();
        headers.set("Authorization", "Bearer " + getTenantToken(appName));
        HttpEntity<String> requestEntity = new HttpEntity<>(headers);
        String url = feiShuConfig.getFeiShuOpenApiHost() + api;
        try {
            ResponseEntity<byte[]> responseEntity = restTemplate.exchange(url, HttpMethod.GET, requestEntity, byte[].class, filePath);
            return responseEntity.getBody();
        } catch (Exception e) {
            throw new ServiceException("飞书：" + api + "接口调用失败" + "\n" + e);
        }
    }

    //上传文件
    public String uploadFile(String file_type, String file_name, Integer duration, byte[] file, String appName) {
        String api = "/im/v1/files";
        RestTemplate restTemplate = new RestTemplate();
        HttpHeaders headers = new HttpHeaders();
        headers.set("Authorization", "Bearer " + getTenantToken(appName));
        headers.setContentType(org.springframework.http.MediaType.MULTIPART_FORM_DATA);
        MultiValueMap<String, Object> param = new LinkedMultiValueMap<>();
        param.add("file_type", file_type);
        param.add("file_name", file_name);
        param.add("duration", duration);
        param.add("file", file);
        HttpEntity<MultiValueMap<String, Object>> requestEntity = new HttpEntity<>(param, headers);
        String url = feiShuConfig.getFeiShuOpenApiHost() + api;
        try {
            ResponseEntity<JSONObject> responseEntity = restTemplate.postForEntity(url, requestEntity, JSONObject.class);
            return responseEntity.getBody().getJSONObject("data").getString("file_key");
        } catch (Exception e) {
            throw new ServiceException("飞书：" + api + "接口调用失败" + "\n" + e);
        }
    }

    //获取应用有权限的所有部门
    public JSONObject getDepartment(String appName) {
        String api = "/contact/v3/departments?fetch_child=true";
        RestTemplate restTemplate = new RestTemplate();
        HttpHeaders headers = new HttpHeaders();
        headers.set("Authorization", "Bearer " + getTenantToken(appName));
        headers.set("Content-Type", "application/json; charset=utf-8");
        HttpEntity<String> requestEntity = new HttpEntity<>(headers);
        String url = feiShuConfig.getFeiShuOpenApiHost() + api;
        try {
            ResponseEntity<JSONObject> responseEntity = restTemplate.exchange(url, HttpMethod.GET, requestEntity, JSONObject.class);
            return responseEntity.getBody();
        } catch (Exception e) {
            throw new ServiceException("飞书：" + api + "接口调用失败" + "\n" + e);
        }
    }

    /**
     * 获取飞书人事花名单信息
     * 文档：https://open.feishu.cn/document/uAjLw4CM/ukTMukTMukTM/ehr/ehr-v1/employee/list
     *
     * @return
     */
    public List<FeiShuEmployeeDTO> getEmployeeList(String appName) {
        return EMPLOYEE_LIST_CACHE.get("employeeList", s -> setEmployeeList(appName));
    }

    private List<FeiShuEmployeeDTO> setEmployeeList(String appName) {
        String api = "/ehr/v1/employees?view=full&status=2&status=4&page_size=100";
        RestTemplate restTemplate = new RestTemplate();
        HttpHeaders headers = new HttpHeaders();
        headers.set("Authorization", "Bearer " + getTenantToken(appName));
        headers.set("Content-Type", "application/json; charset=utf-8");
        HttpEntity<String> requestEntity = new HttpEntity<>(headers);
        String url = feiShuConfig.getFeiShuOpenApiHost() + api;
        try {
            ResponseEntity<String> responseEntity = restTemplate.exchange(url, HttpMethod.GET, requestEntity, String.class);
            Type type = new TypeReference<FeiShuResultDTO<FeiShuEmployeeDTO>>() {
            }.getType();
            FeiShuResultDTO feiShuResultDTO = JSONObject.parseObject(responseEntity.getBody(), type);
            List<FeiShuEmployeeDTO> feiShuEmployeeDTOList = new ArrayList<>();
            feiShuEmployeeDTOList.addAll(feiShuResultDTO.getData().getItems());
            while (feiShuResultDTO.getData().getItems().size() >= 100) {
                ResponseEntity<String> next = restTemplate.exchange(url + "&page_token=" + feiShuResultDTO.getData().getPageToken(), HttpMethod.GET, requestEntity, String.class);
                feiShuResultDTO = JSONObject.parseObject(next.getBody(), type);
                feiShuEmployeeDTOList.addAll(feiShuResultDTO.getData().getItems());
            }
            log.info("花名册获取完成，总计 {} 人", feiShuEmployeeDTOList.size());
            return feiShuEmployeeDTOList;
        } catch (Exception e) {
            throw new ServiceException("飞书：" + api + "接口调用失败" + "\n" + e);
        }
    }

    /**
     * 获取机器人所在群信息
     * https://open.feishu.cn/document/uAjLw4CM/ukTMukTMukTM/reference/im-v1/chat/list
     *
     * @return
     */
    public List<FeiShuChatDTO> getChatList(String appName) {
        String api = "/im/v1/chats";
        RestTemplate restTemplate = new RestTemplate();
        HttpHeaders headers = new HttpHeaders();
        headers.set("Authorization", "Bearer " + getTenantToken(appName));
        headers.set("Content-Type", "application/json; charset=utf-8");
        HttpEntity<String> requestEntity = new HttpEntity<>(headers);
        String url = feiShuConfig.getFeiShuOpenApiHost() + api;
        try {
            ResponseEntity<String> responseEntity = restTemplate.exchange(url, HttpMethod.GET, requestEntity, String.class);
            Type type = new TypeReference<FeiShuResultDTO<FeiShuChatDTO>>() {
            }.getType();
            System.out.println(responseEntity.getBody());
            FeiShuResultDTO feiShuResultDTO = JSONObject.parseObject(responseEntity.getBody(), type);
            return feiShuResultDTO.getData().getItems();
        } catch (Exception e) {
            throw new ServiceException("飞书：" + api + "接口调用失败" + "\n" + e);
        }
    }

    /**
     * 群发消息
     * https://open.feishu.cn/document/ukTMukTMukTM/ucDO1EjL3gTNx4yN4UTM
     */
    public void sendBatchMsg(FeiShuBatchMsgDTO feiShuBatchMsgDTO, String appName) {
        String api = "/message/v4/batch_send/";
        RestTemplate restTemplate = new RestTemplate();
        try {
            HttpHeaders headers = new HttpHeaders();
            headers.set("Authorization", "Bearer " + getTenantToken(appName));
            headers.set("Content-Type", "application/json; charset=utf-8");
            HttpEntity<String> requestEntity = new HttpEntity<>(objectMapper.writeValueAsString(feiShuBatchMsgDTO), headers);
            String url = feiShuConfig.getFeiShuOpenApiHost() + api;

            ResponseEntity<String> responseEntity = restTemplate.exchange(url, HttpMethod.POST, requestEntity, String.class);
            log.info("批量发送消息返回：{}", responseEntity);
        } catch (Exception e) {
            throw new ServiceException("飞书：" + api + "接口调用失败" + "\n" + e);
        }
    }

    /**
     * 单发消息
     * https://open.feishu.cn/document/uAjLw4CM/ukTMukTMukTM/reference/im-v1/message/create
     *
     * @param feiShuMsgDTO
     */
    public void sendMsg(FeiShuMsgDTO feiShuMsgDTO, String receiveIdType, String appName) {
        String api = "/im/v1/messages?receive_id_type={receiveIdType}";
        RestTemplate restTemplate = new RestTemplate();
        try {
            HttpHeaders headers = new HttpHeaders();
            headers.set("Authorization", "Bearer " + getTenantToken(appName));
            headers.set("Content-Type", "application/json; charset=utf-8");
            HttpEntity<String> requestEntity = new HttpEntity<>(objectMapper.writeValueAsString(feiShuMsgDTO), headers);
            String url = feiShuConfig.getFeiShuOpenApiHost() + api;

            ResponseEntity<String> responseEntity = restTemplate.exchange(url, HttpMethod.POST, requestEntity, String.class, receiveIdType);
            log.info("单发消息成功, req：{}, resp: {}", feiShuMsgDTO, responseEntity);
        } catch (Exception e) {
            log.error("单发消息失败", e);
        }
    }

    /**
     * 根据部门id查询部门信息
     * https://open.feishu.cn/document/uAjLw4CM/ukTMukTMukTM/reference/contact-v3/department/get
     *
     * @param departmentId
     * @return
     */
    public FeiShuDepartmentDTO getDepartment(String departmentId, String appName) {
        String api = "/contact/v3/departments/{departmentId}";
        RestTemplate restTemplate = new RestTemplate();
        HttpHeaders headers = new HttpHeaders();
        headers.set("Authorization", "Bearer " + getTenantToken(appName));
        headers.set("Content-Type", "application/json; charset=utf-8");
        HttpEntity<String> requestEntity = new HttpEntity<>(headers);
        String url = feiShuConfig.getFeiShuOpenApiHost() + api;
        try {
            ResponseEntity<String> responseEntity = restTemplate.exchange(url, HttpMethod.GET, requestEntity, String.class, departmentId);
            Type type = new TypeReference<FeiShuResultDTO>() {
            }.getType();
            FeiShuResultDTO feiShuResultDTO = JSONObject.parseObject(responseEntity.getBody(), type);
            return feiShuResultDTO.getData().getDepartment();
        } catch (Exception e) {
            throw new ServiceException("飞书：" + api + "接口调用失败" + "\n" + e);
        }
    }

    /**
     * 列出文档记录
     * https://open.feishu.cn/document/uAjLw4CM/ukTMukTMukTM/reference/bitable-v1/app-table-record/list
     *
     * @param appToken
     * @param tableId
     * @param appName
     * @return
     */
    public List getTableRecords(String appToken, String tableId, String appName) {
        String api = "/bitable/v1/apps/{app_token}/tables/{table_id}/records";
        RestTemplate restTemplate = new RestTemplate();
        HttpHeaders headers = new HttpHeaders();
        headers.set("Authorization", "Bearer " + getTenantToken(appName));
        headers.set("Content-Type", "application/json; charset=utf-8");
        HttpEntity<String> requestEntity = new HttpEntity<>(headers);
        String url = feiShuConfig.getFeiShuOpenApiHost() + api;
        List list = new ArrayList();
        try {
            ResponseEntity<String> responseEntity = restTemplate.exchange(url, HttpMethod.GET, requestEntity, String.class, appToken, tableId);
            Type type = new TypeReference<FeiShuResultDTO<DocDTO<FieldsDTO>>>() {
            }.getType();
            FeiShuResultDTO feiShuResultDTO = JSONObject.parseObject(responseEntity.getBody(), type);
            list = feiShuResultDTO.getData().getItems();
            while (feiShuResultDTO.getData().getItems().size() >= 100) {
                ResponseEntity<String> next = restTemplate.exchange(url + "&page_token=" + feiShuResultDTO.getData().getPageToken(), HttpMethod.GET, requestEntity, String.class, appToken, tableId);
                feiShuResultDTO = JSONObject.parseObject(next.getBody(), type);
                list.addAll(feiShuResultDTO.getData().getItems());
            }
            return list;
        } catch (Exception e) {
            throw new ServiceException("飞书：" + api + "接口调用失败" + "\n" + e);
        }

    }


    /**
     * 更新记录
     *
     * @param appToken
     * @param tableId
     * @param recordId
     * @param appName
     * @param docDTO
     * @return
     */
    public FeiShuResultDTO updateTableRecords(String appToken, String tableId, String recordId, String appName, DocDTO docDTO) {
        String api = "/bitable/v1/apps/{app_token}/tables/{table_id}/records/{record_id}";
        RestTemplate restTemplate = new RestTemplate();
        HttpHeaders headers = new HttpHeaders();
        headers.set("Authorization", "Bearer " + getTenantToken(appName));
        headers.set("Content-Type", "application/json; charset=utf-8");

        HttpEntity<String> requestEntity = new HttpEntity<>(JSONObject.toJSONString(docDTO), headers);
        String url = feiShuConfig.getFeiShuOpenApiHost() + api;
        try {
            ResponseEntity<String> responseEntity = restTemplate.exchange(url, HttpMethod.PUT, requestEntity, String.class, appToken, tableId, recordId);
            FeiShuResultDTO feiShuResultDTO = JSONObject.parseObject(responseEntity.getBody(), FeiShuResultDTO.class);
            return feiShuResultDTO;
        } catch (Exception e) {
            throw new ServiceException("飞书：" + api + "接口调用失败" + "\n" + e);
        }

    }
}