เมื่ออยากมี Tools ส่วนตัวใช้ในชีวิตประจำวันผ่าน LINE

{
  "name": "jasistant",
  "version": "1.0.0",
  "description": "Personal assitants for backend line bot.",
  "main": "server.js",
  "scripts": {
    "start": "node server.js"
  },
  "dependencies": {
    "@google-cloud/storage": "^6.10.0",
    "@google-cloud/vision": "^3.1.3",
    "@line/bot-sdk": "^7.5.2",
    "airtable": "^0.11.6",
    "body-parser": "^1.20.2",
    "date-fns": "^2.30.0",
    "dotenv": "^16.0.3",
    "express": "^4.18.2",
    "nanoid": "^3.3.6",
    "promptpay-qr": "^0.5.0",
    "qrcode": "^1.5.3",
    "uuid": "^9.0.0"
  },
  "engines": {
    "node": ">=14"
  },
  "repository": {
    "url": "https://github.com/Janescience/jasistant.git"
  },
  "license": "MIT",
  "keywords": [
    "node",
    "assitants",
    "line",
    "bot"
  ]
}

// Import NPM
const express = require('express');
const bodyParser = require('body-parser')
const path = require("path");
const errorHandler  = require('./src/middlewares/error-handler');
const dotenv = require('dotenv');
dotenv.config();

// Initialize express app 
const app = express();
app.use(express.json({limit:'50mb'}))
app.use(express.urlencoded({limit: '50mb', extended:true }))
app.use(express.static(path.join(__dirname, '/public')))
app.use(bodyParser.text())

// Routes setup  
require('./src/routes/webhook.routes')(app);

// Basic route
app.get(["/","/index.html"],(req,res) => {
  res.sendFile(path.join(__dirname, 'views','index.html'));
})

// Not found route
app.all("*", (req,res) => {
  res.status(404);
  if(req.accepts('html')){
    res.sendFile(path.join(__dirname, 'views','404.html'));
  } else if (req.accepts('json')) {
    res.json({error : "404 Not Found"});
  }else {
    res.type('txt').send('404 Not Found')
  }
})

//Error handler
app.use(errorHandler)

//App started
app.listen(process.env.PORT, () => {
  console.log("Server is running on port : ",process.env.PORT);
})

const dotenv = require('dotenv');
dotenv.config();

const config = () => {
    return { 
        channelAccessToken: process.env.LINE_CHANNEL_ACCESS_TOKEN,
        channelSecret: process.env.LINE_CHANNEL_SECRET
    }
}

module.exports = config

const toMessages = (data) => {
  if (!data) data = "Data reply is undefined..."
  if (typeof data === "string") data = [{ type: "text", text: data }]
  return data
}
  
const createBubble = (
  title,
  text,
  {
    headerBackground = "#353433",
    headerColor = "#d7fc70",
    textSize = "xl",
    altText = String(text),
    footer
  } = {}
) => {
  const data = {
    type: "bubble",
    styles: {
      header: { backgroundColor: headerBackground }
    },
    header: {
      type: "box",
      layout: "vertical",
      contents: [
        { type: "text", text: title, color: headerColor, weight: "bold" }
      ]
    },
    body:
      typeof text === "string"
        ? {
            type: "box",
            layout: "vertical",
            contents: [{ type: "text", text: text, wrap: true, size: textSize }]
          }
        : text
  }
  if (footer) {
    data.styles.footer = { backgroundColor: "#e9e8e7" }
    data.footer =
      typeof footer === "string"
        ? {
            type: "box",
            layout: "vertical",
            contents: [
              {
                type: "text",
                text: footer,
                wrap: true,
                size: "sm",
                color: "#8b8685"
              }
            ]
          }
        : footer
  }
  return {
    type: "flex",
    altText: truncate(`[${title}] ${altText}`, 400),
    contents: data
  }
}

const  truncate = (text, maxLength) => {
  return text.length + 5 > maxLength
    ? text.substr(0, maxLength - 5) + "…"
    : text
}

const readAsBuffer = (stream) => {
  return new Promise((resolve, reject) => {
    stream.on("error", e => {
      reject(e)
    })
    const bufs = []
    stream.on("end", () => {
      resolve(Buffer.concat(bufs))
    })
    stream.on("data", buf => {
      bufs.push(buf)
    })
  })
}
  
const utility = {
  toMessages,
  createBubble,
  readAsBuffer
};

module.exports = utility;
  

const { Storage } = require("@google-cloud/storage")
const { nanoid } = require("nanoid")

const storage = new Storage(
  {
    projectId: process.env.GCS_PROJECT_ID,
    scopes: 'https://www.googleapis.com/auth/cloud-platform',
    credentials: {
      client_email: process.env.GCS_EMAIL,
      private_key: process.env.GCS_PRIVATE_KEY
    }
  }
);

const putBlob = async (buffer, extension) => {
  const blobName = nanoid() + extension
  await storage
    .bucket("tmpblobimg")
    .file(blobName)
    .save(buffer)
  return blobName
}

const getBlob = async (blobName) => {
  const response = await storage
    .bucket("tmpblobimg")
    .file(blobName)
    .download()
  return response[0]
}

const deleteBlob = async (blobName) => {
  await storage
    .bucket("tmpblobimg")
    .file(blobName)
    .delete();
}

const getBlobUrl = async (blobName) => {
  const result = await storage
    .bucket("tmpblobimg")
    .file(blobName)
    .getSignedUrl({
      action: "read",
      expires: new Date(Date.now() + 86400e3),
      version: "v4",
      virtualHostedStyle: true
    })
  return result[0]
}

const cloudStorage = {
  putBlob,
  getBlob,
  deleteBlob,
  getBlobUrl
};

module.exports = cloudStorage;

const Airtable = require("airtable");
const { AirtableRecord } = require("airtable");
const { createBubble } = require("../utilities/line.utility");

const expenseTable = () => {
  return new Airtable({ apiKey: process.env.AIRTABLE_API_KEY })
    .base(process.env.AIRTABLE_EXPENSE_BASE)
    .table("Expense Records");
};

const expenseTracking = async (time,name,amount, category) => {
  const date = time ? time : new Date();
  // Airtable
  const recorded = await expenseTable().create(
    {
      Name: name.trim(),
      Date: date,
      Category: category,
      Amount: amount,
    },
    { typecast: true }
  );
  const body = {
    type: "box",
    layout: "vertical",
    contents: [
      {
        type: "text",
        text: "฿" + amount,
        size: "xxl",
        weight: "bold",
      },
      {
        type: "text",
        text: `${category}${name ? "\n" + name.trim() : ""}`,
        wrap: true,
      },
    ],
    action: {
      type: "uri",
      label: "Open Airtable",
      uri: process.env.AIRTABLE_EXPENSE_URI + "/" + recorded.getId(),
    },
  };
  const footer = await summary();
  const bubble = createBubble("Expense Tracking", body, {
    headerColor: "#f7f7f2",
    footer: {
      type: "box",
      layout: "horizontal",
      spacing: "sm",
      contents: footer.map(([label, text]) => ({
        type: "box",
        layout: "vertical",
        contents: [
          {
            type: "text",
            text: label,
            color: "#8b8685",
            size: "xs",
            align: "end",
          },
          {
            type: "text",
            text: text,
            color: "#8b8685",
            size: "sm",
            align: "end",
          },
        ],
      })),
      action: {
        type: "uri",
        label: "Open Airtable",
        uri: process.env.AIRTABLE_EXPENSE_URI,
      },
    },
  });
  return {message:bubble};
};

const summary = async () => {
  const date = new Date().toJSON().split("T")[0];
  const tableData = await expenseTable().select().all();
  const normalRecords = tableData.filter((r) => !r.get("Occasional"));
  const records = AirtableRecord;
  const total = (records) => records.map((r) => +r.get("Amount") || 0).reduce((a, b) => a + b, 0);
  const firstDate = normalRecords
    .map((r) => (r.get("Date") ? r.get("Date").split("T")[0] : r.get("Date")))
    .reduce((a, b) => (a < b ? a : b), date);

  const todayUsage = total(
    normalRecords.filter(
      (r) => (r.get("Date") ? r.get("Date").split("T")[0] : r.get("Date")) === date
    )
  );
  const dayNumber = Math.round((Date.parse(date) - Date.parse(firstDate)) / 86400e3) + 1;
  const $ = (v) => `฿${v.toFixed(2)}`;

  return [
    ["Today", $(todayUsage)], //รายจ่ายรวมทั้งหมดของวันนี้
    ["Day", `${dayNumber}`], //รวมแล้วมีการบันทึกรายจ่ายทั้งหมดกี่วัน
  ];
};

module.exports = expenseTracking;

const qrcode = require('qrcode')
const generatePayload = require('promptpay-qr')
const { putBlob,getBlobUrl } = require('../utilities/storage.utility')

const generateQrcode = async (amount) => {

  const mobileNumber = '080-608-XXXX'
  const payload = generatePayload(mobileNumber, { amount })
  
  const bufferImage = await qrcode.toBuffer(payload, {
      type: 'jpg',
      errorCorrectionLevel: 'H',
  });

  const blobName = await putBlob(bufferImage, ".jpg")
  const blobUrl = await getBlobUrl(blobName)

  const message = 
  [
    {
      type: 'image',
      originalContentUrl: blobUrl,
      previewImageUrl: blobUrl
    },
    {
      type: "text",
      text: `${amount} บาท`,
    }
  ]
  
  return {
      message: message,
      blobName : blobName
    }
}

module.exports = generateQrcode;

const expenseTracking = require("../modules/expense-tracking.module")
const qrcodePromptpay = require("../modules/qrcode-promptpay.module")

const category = {
  t: "transportation",
  f: "food",
  e: "electronic",
  d: "drinks",
  c: "clothes",
  a: "alcohal",
  g: "game",
  h: "health",
  m: "miscellaneous",
  o: "occasion",
  l: "lodging"
}

const messageService = async (message) =>{
    message = message.trim()
    let match
    if (match = message.match(/^([\d.]+|[ivxlcdm]+)([tfedcaghmol])([ \w]+|)$/i)) {//บันทึกรายจ่าย

      const m = match
      
      const enteredAmount = +m[1]
      const amount = enteredAmount.toFixed(2)
      const ctg = category[m[2].toLowerCase()]
      const name = m[3] ? m[3] : ""

      return await expenseTracking(null,name,amount, ctg)
    }else if(match = message.match(/^(expctg)$/i)){//ขอดู Category
      return {message :  JSON.stringify(category,null,4) }
    }else if(match = message.match(/^(qr)([\d.]+)$/i)){//สร้าง QRCode
      const m = match
      const amount = Number(match[2])
      return await qrcodePromptpay(amount)
    }
}

module.exports = messageService;

const vision = require('@google-cloud/vision')
const { getBlob,putBlob } =  require('../utilities/storage.utility')

const imageService = async (buffer) => {

    //Upload image to google cloud storage(buckets)
    const blobName = await putBlob(buffer, ".jpg")

    const blob = await getBlob(blobName)

    const imageAnnotator = new vision.ImageAnnotatorClient(
        {
            projectId: process.env.GCS_PROJECT_ID,
            scopes: 'https://www.googleapis.com/auth/cloud-platform',
            credentials: {
              client_email: process.env.GCS_EMAIL,
              private_key: process.env.GCS_PRIVATE_KEY
            }
        }
    );
    const results = await imageAnnotator.documentTextDetection(blob)
    const fullTextAnnotation = results[0].fullTextAnnotation
    
    let blocks = []
    
    for (const page of fullTextAnnotation.pages) {
        blocks.push(
            ...page.blocks.map((block) => {
            return block.paragraphs
                .map((p) =>
                p.words
                    .map((w) => w.symbols.map((s) => s.text).join(''))
                    .join(' ')
                )
                .join('\n\n')
            })
        )
    }
        
    const responses = blocksToResponses(blocks)
    return {message:responses.map((r) => ({ type: 'text', text: r })),blobName:blobName}
}

const blocksToResponses = (blocks) => {
        
    if (blocks.length <= 4) return blocks
    
    let processedIndex = 0
    const outBlocks = []
    
    for (let i = 0; i < 4; i++) {
      const targetIndex = Math.ceil(((i + 1) * blocks.length) / 4)
      outBlocks.push(
        blocks
          .slice(processedIndex, targetIndex)
          .map((x) => `・ ${x}`)
          .join('\n')
      )
      processedIndex = targetIndex
    }
    
    return outBlocks
}

module.exports = imageService;

const config = require("../config/line.config");
const messageService = require("../services/message.service");
const imageService = require("../services/image.service");

const { Client } =  require('@line/bot-sdk')
const { toMessages,readAsBuffer } = require('../utilities/line.utility')
const { deleteBlob } = require('../utilities/storage.utility')

exports.webhook = async (req, res) => {
    const client = new Client(config())
    const events = req.body.events;
    return await handleWebhook(events, client)
};

const handleWebhook = async (events, client) => {
  for (const event of events) {
    if (event.type === "message") {
      await messageEvent(event,client)
    }
  }
}

const messageEvent = async (event,client) => {
    const { replyToken, message } = event
    try {
        //Validate
        if(event.source.userId !== process.env.LINE_USER_ID){
            await client.replyMessage(replyToken,toMessages('unauthorized'))
            return 
        }

        if (message.type === 'text') { //Text
            const reply = await messageService(message.text)
            await client.replyMessage(replyToken,toMessages(reply.message))
            if(reply.blobName){
                setTimeout(() => {
                    deleteBlob(reply.blobName);
                }, 3000);
            }
        }else if (message.type === 'image') { //Image
            const content = await client.getMessageContent(message.id)
            const buffer = await readAsBuffer(content)
            const reply = await imageService(buffer)
            await client.replyMessage(replyToken, toMessages(reply.message))
            if(reply.blobName){
                setTimeout(() => {
                    deleteBlob(reply.blobName);
                }, 3000);
            }
        }
    } catch (error) { 
        await client.replyMessage(replyToken,toMessages(error))
    }
}