コラボフロー Webhook と REST API を活用して申請終了時に添付ファイルをバックアップする

[package]
name = "collaboflow-backup-lambda"
version = "0.1.0"
edition = "2021"

[dependencies]
lambda_http = "0.8.3"
lambda_runtime = "0.8.3"
tokio = { version = "1", features = ["macros"] }
tracing = { version = "0.1", features = ["log"] }
tracing-subscriber = { version = "0.3", default-features = false, features = ["fmt"] }
serde_json = "1.0.108"
serde = { version = "1.0.193", features = ["derive"] }
collaboflow-rs = "0.0.13"
config = "0.13.4"
clap = "4.4.11"
time = "0.3.30"
structopt = { version = "0.3.26", features = [] }
object = { version = "0.32.1", features = [] }
aws-config= { version = "1.0.3", features = ["behavior-version-latest"] }
aws-sdk-s3= { version = "1.5.0", features = ["rt-tokio"] }

{
    "contents": {
        "fidFile": {
            "label": "ファイル名",
            "link": "ダウンロード URL",
            "value": "ファイル ID",
            "type": "attachment"
        }
    }
}

use collaboflow_rs::bytes::Bytes;
use collaboflow_rs::{Authorization, CollaboflowClient};
use serde::{Deserialize, Serialize};
use serde_json::Value;
use std::env;

#[derive(Clone, Debug, Deserialize, Serialize)]
pub struct CollaboflowWebhookResponse {
    contents: Value,
}

#[derive(Clone, Debug)]
pub struct BackupFile {
    pub id: String,
    pub name: String,
}

pub fn get_file_info(s: &str) -> Result<BackupFile, ()> {
    let resp = match serde_json::from_str::<CollaboflowWebhookResponse>(s) {
        Ok(resp) => resp,
        Err(_) => {
            return Err(());
        }
    };

    let fid =
        env::var("BACKUP_FID_KEY").unwrap_or_else(|_| panic!("{} is undefined.", "BACKUP_FID_KEY"));

    // ファイルIDを取得する
    let id = match resp.contents.get(&fid) {
        None => "".to_string(),
        Some(fid_file) => match fid_file.get("value") {
            None => "".to_string(),
            Some(value) => match value.as_str() {
                None => "".to_string(),
                Some(v) => v.to_string(),
            },
        },
    };

    // ファイル名を取得する
    let name = match resp.contents.get(&fid) {
        None => "".to_string(),
        Some(fid_file) => match fid_file.get("label") {
            None => "".to_string(),
            Some(value) => match value.as_str() {
                None => "".to_string(),
                Some(v) => v.to_string(),
            },
        },
    };

    Ok(BackupFile { id, name })
}

pub async fn download_file(id: &str) -> Result<Bytes, ()> {
    let client = collaboflow_client();

    // ファイルをダウンロード
    match client.files.get(id).await {
        Ok(resp) => Ok(resp.body),
        Err(_) => Err(()),
    }
}

pub fn collaboflow_client() -> CollaboflowClient {
    // コラボフローに接続するための情報を環境変数から取得する
    let authorization = Authorization::with_api_key(
        env::var("CF_USER_ID")
            .unwrap_or_else(|_| panic!("{} is undefined.", "CF_USER_ID"))
            .as_str(),
        env::var("CF_API_KEY")
            .unwrap_or_else(|_| panic!("{} is undefined.", "CF_API_KEY"))
            .as_str(),
    );

    // コラボフロー REST API クライアントを生成する
    CollaboflowClient::new(
        env::var("CF_BASE_URL")
            .unwrap_or_else(|_| panic!("{} is undefined.", "CF_BASE_URL"))
            .as_str(),
        authorization,
    )
}

use aws_config::meta::region::RegionProviderChain;
use aws_sdk_s3::primitives::ByteStream;
use aws_sdk_s3::{config::Region, Client};
use collaboflow_rs::bytes::Bytes;
use std::error::Error;
use tracing::info;

pub async fn put_object(bucket: &str, key: &str, data: Bytes) -> Result<(), Box<dyn Error>> {
    let region = Some("ap-northeast-1");
    let region_provider = RegionProviderChain::first_try(region.map(Region::new))
        .or_default_provider()
        .or_else(Region::new("ap-northeast-1"));
    let shared_config = aws_config::from_env().region(region_provider).load().await;
    let client = Client::new(&shared_config);

    let body = ByteStream::from(data.to_vec());
    let request = client
        .put_object()
        .bucket(bucket)
        .key(key)
        .body(body)
        .send()
        .await?;

    info!("{:?}", request);

    Ok(())
}

mod collaboflow;
mod s3;

use crate::collaboflow::{download_file, get_file_info};
use crate::s3::put_object;
use lambda_http::{run, service_fn, Body, Error, Request, Response};
use std::env;

async fn function_handler(event: Request) -> Result<Response<Body>, Error> {
    let body = event.body();
    let s = std::str::from_utf8(body).expect("invalid utf-8 sequence");

    // Serialize JSON into struct.
    // If JSON is incorrect, send back 400 with error.
    let backup_file = match get_file_info(s) {
        Ok(info) => info,
        Err(_) => {
            let resp = Response::builder()
                .status(400)
                .header("content-type", "text/html")
                .body("Error...".into())
                .map_err(Box::new)?;
            return Ok(resp);
        }
    };

    if !backup_file.id.is_empty() {
        let bucket = env::var("BACKUP_BUCKET_NAME")
            .unwrap_or_else(|_| panic!("{} is undefined.", "BACKUP_BUCKET_NAME"));

        // コラボフローからファイルを取得する
        if let Ok(data) = download_file(&backup_file.id).await {
            // ファイルIDでフォルダを作成し、その中にファイルを保存する
            let key = format!("{}/{}", &backup_file.id, &backup_file.name);
            let _ = put_object(&bucket, &key, data).await;
        }
    }

    // Return something that implements IntoResponse.
    // It will be serialized to the right response event automatically by the runtime
    let resp = Response::builder()
        .status(200)
        .header("content-type", "text/html")
        .body("Success!".into())
        .map_err(Box::new)?;
    Ok(resp)
}

#[tokio::main]
async fn main() -> Result<(), Error> {
    tracing_subscriber::fmt()
        .with_max_level(tracing::Level::INFO)
        // disable printing the name of the module in every log line.
        .with_target(false)
        // disabling time is handy because CloudWatch will add the ingestion time.
        .without_time()
        .init();

    run(service_fn(function_handler)).await
}

cargo lambda build --release
cargo lambda deploy --enable-function-url