office_xbot_feishu/app/demo.py

import os
import json
from itertools import chain

import lark_oapi as lark

from flask import Flask
from dotenv import load_dotenv
from lark_oapi.adapter.flask import *
from lark_oapi.api.im.v1 import *
from lark_oapi.api.bitable.v1 import *


from utils import get_message_resource, upload_media


load_dotenv()

app_id = os.environ["APP_ID"]
app_secret = os.environ["APP_SECRET"]

encrypt_key = os.environ["ENCRYPT_KEY"]
verification_token = os.environ["VERIFICATION_TOKEN"]

bitable_token = os.environ["BITABLE_TOKEN"]
table_id = os.environ["TABLE_ID"]


current_dir = os.path.dirname(os.path.abspath(__file__))


# 创建client
client = lark.Client.builder().app_id(app_id).app_secret(app_secret).build()
cache_dir = os.path.join(current_dir, "cache")

if not os.path.exists(cache_dir):
    os.makedirs(cache_dir)


app = Flask(__name__)


def do_p2_im_message_receive_v1(data: P2ImMessageReceiveV1) -> None:
    print(lark.JSON.marshal(data))
    record = {}
    images = []
    message_content = ""
    message_type = data.event.message.message_type
    content = data.event.message.content
    content = json.loads(content)
    if message_type == "post":
        content = content["content"]
        for item in chain.from_iterable(content):
            if item.get("tag") == "text":
                message_content += item["text"]

            if item.get("tag") == "img":
                images.append(item["image_key"])

    if message_type == "text":
        message_content = content["text"].replace("@_user_1", "").strip()

    record["问题概述"] = message_content
    record["创建人"] = data.event.sender.sender_id.open_id
    receive_open_id = data.event.sender.sender_id.open_id
    message_id = data.event.message.message_id
    user_id = data.event.sender.sender_id.user_id

    if images:
        record["附件"] = [{"file_token": image} for image in images]

    # 对 image_key 处理并并上传至多维表格
    images_path = []
    for image in images:
        image_path = get_message_resource(client, message_id, image, "image", cache_dir)
        print("下载文件成功:", image, image_path)
        images_path.append(image_path)
        file_token = upload_media(client, image_path, "bitable_image", bitable_token)
        print("上传文件成功:", file_token)

    add_record(record)

    # content = {"text": "反馈的问题已经记录到多维表格, 稍后有小伙伴跟进"}
    # send_message(receive_id, content)

    # 回复群组的消息
    content = f'{{"text": "反馈的问题已经记录到多维表格, 稍后有小伙伴跟进"}}'
    send_group_message(message_id, content)


def do_customized_event(data: lark.CustomizedEvent) -> None:
    print(lark.JSON.marshal(data))


handler = (
    lark.EventDispatcherHandler.builder(
        encrypt_key, verification_token, lark.LogLevel.DEBUG
    )
    .register_p2_im_message_receive_v1(do_p2_im_message_receive_v1)
    .register_p1_customized_event("message", do_customized_event)
    .build()
)


def add_record(data):
    # 构造请求对象
    request: CreateAppTableRecordRequest = (
        CreateAppTableRecordRequest.builder()
        .app_token(bitable_token)
        .table_id(table_id)
        .request_body(AppTableRecord.builder().fields(data).build())
        .build()
    )

    # 发起请求
    response: CreateAppTableRecordResponse = client.bitable.v1.app_table_record.create(
        request
    )

    # 处理失败返回
    if not response.success():
        lark.logger.error(
            f"client.bitable.v1.app_table_record.create failed, code: {response.code}, msg: {response.msg}, log_id: {response.get_log_id()}"
        )
        return

    # 处理业务结果
    lark.logger.info(lark.JSON.marshal(response.data, indent=4))


def send_group_message(message_id, content):
    # 构造请求对象

    request: ReplyMessageRequest = (
        ReplyMessageRequest.builder()
        .message_id(message_id)
        .request_body(
            ReplyMessageRequestBody.builder()
            .content(content=content)
            .msg_type("text")
            .reply_in_thread(True)
            .build()
        )
        .build()
    )

    # 发起请求
    response: ReplyMessageResponse = client.im.v1.message.reply(request)

    # 处理失败返回
    if not response.success():
        lark.logger.error(
            f"client.im.v1.message.reply failed, code: {response.code}, msg: {response.msg}, log_id: {response.get_log_id()}"
        )

    # 处理业务结果
    lark.logger.info(lark.JSON.marshal(response.data, indent=4))


def send_message(receive_id, content):
    # 构造请求对象
    request: CreateMessageRequest = (
        CreateMessageRequest.builder()
        .receive_id_type("open_id")
        .request_body(
            CreateMessageRequestBody.builder()
            .receive_id(receive_id)
            .msg_type("text")
            .content(content)
            .build()
        )
        .build()
    )

    # 发起请求
    response: CreateMessageResponse = client.im.v1.message.create(request)

    # 处理失败返回
    if not response.success():
        lark.logger.error(
            f"client.im.v1.message.create failed, code: {response.code}, msg: {response.msg}, log_id: {response.get_log_id()}"
        )
        return

    # 处理业务结果
    lark.logger.info(lark.JSON.marshal(response.data, indent=4))


@app.route("/event", methods=["POST"])
def event():
    resp = handler.do(parse_req())
    return parse_resp(resp)


if __name__ == "__main__":
    app.run(port=8080, debug=True, host="0.0.0.0")