[TypeScript] BoltでSlack Appを作成する ④Notion APIを叩いてタスク一覧を取得する

NOTION_API_TOKEN=secret_*************

npm install firebase-admin

{
  "type": "service_account",
  "project_id": "sample",
  "private_key_id": "66…",
  "private_key": "-----BEGIN PRIVATE KEY-----\nMI…",
  "client_email": "sample@appspot.gserviceaccount.com",
  "client_id": "11…",
  "auth_uri": "https://accounts.google.com/o/oauth2/auth",
  "token_uri": "https://oauth2.googleapis.com/token",
  "auth_provider_x509_cert_url": "https://www.googleapis.com/oauth2/v1/certs",
  "client_x509_cert_url": "https://www.googleapis.com/robot/v1/metadat…",
  "databaseURL": "https://sample.firebaseio.com" // ここです
}

/
├── users
|   ├ *****(UID)
|   | ├ name
|   | ├ notion_id
|   | └ slack_id
|   └ *****(UID)
└── notion
    ├ *****(UID)
    | ├ title(ex: Tasks)
    | └ id
    └ *****(UID)

import * as admin from 'firebase-admin'

if (process.env.NODE_ENV === `production`) {
  admin.initializeApp({
    credential: admin.credential.applicationDefault(),
  })
} else {
  const serviceAccount = require(`../../serviceAccountKey.json`)
  admin.initializeApp({
    credential: admin.credential.cert(serviceAccount),
  })
}
export const firestore = admin.firestore()

import { firestore } from '../initializers/firestore'

const notionIdToSlackId = async (id: string): Promise<string> => {
  const targetUserRef = await firestore.collection('users').where('notion_id', '==', id).get()
  const targetUser = await targetUserRef.docs.map(doc => {
    return doc.data()
  })[0]
  return targetUser.slack_id
}

const slackIdToNotionId = async (id: string): Promise<string> => {
  const targetUserRef = await firestore.collection('users').where('slack_id', '==', id).get()
  const targetUser = await targetUserRef.docs.map(doc => {
    return doc.data()
  })[0]
  return targetUser.notion_id
}

export { notionIdToSlackId, slackIdToNotionId }

import { firestore } from '../initializers/firestore'

export default async (title: string): Promise<string> => {
  const targetNotionDbRef = await firestore.collection('notion').where('title', '==', title).get()
  const targetNotionDb = await targetNotionDbRef.docs.map(doc => {
    return doc.data()
  })[0]
  return targetNotionDb.id
}

import axios from 'axios'
import formatTaskResult from './formatTaskResult'
import fetchNotionDbId from './fetchNotionDbId'

interface Result { // ここはNotionに設定している値を元に作成します
  url: string
  title: string
  startsAt?: string
  endsAt?: string
  assignee?: string
  status?: string
  [key: string]: any
}

export default async (bodyParameters: object): Promise<Result[]> => {
  const tasksDbId = await fetchNotionDbId('Tasks')
  const headers = {
    headers: { 
      Authorization: `Bearer ${process.env.NOTION_API_TOKEN}`,
      'Notion-Version': '2021-08-16'
    }
  }

  try {
    const results = await axios.post(`https://api.notion.com/v1/databases/${tasksDbId}/query`, bodyParameters, headers)
    const array: Result[] = []
    for (const result of results.data['results']) {
      array.push(await formatTaskResult(result))
    }
    return array
  } catch (error) {
    return []
  }
}

import { notionIdToSlackId } from './convertIds'

interface Result {
  url: string
  title: string
  startsAt?: string
  endsAt?: string
  assignee?: string
  status?: string
  [key: string]: any
}

export default async (result: JSON): Promise<Result> => {
  const regex = /[¥-]/g
  const url = `https://www.notion.so/${result['id'].replace(regex, '')}`
  const title = result['properties']['Name']['title'][0]['plain_text']
  const startsAt = result['properties']['Starts at']['date'] != null ? result['properties']['Starts at']['date']['start'] : '未記入'
  const endsAt = result['properties']['Ends at']['date'] != null ? result['properties']['Ends at']['date']['start'] : '未記入'
  const assignee = await getNames(result['properties']['Asignee']['people'])
  const status = result['properties']['status']['select'] != null ? result['properties']['status']['select']['name'] : '未設定'

  return {
    url: url,
    title: title,
    startsAt: startsAt,
    endsAt: endsAt,
    assignee: assignee,
    status: status,
  }
}

const getNames = async (people: JSON[]): Promise<string> => {
  let mentions: string = ''

  for (const person of people) {
    const slackId = await notionIdToSlackId(person['id'])
    mentions = `${mentions} <@${slackId}>`
  }
  return mentions
}

import { app } from '../initializers/bolt'
import fetchTasks from '../functions/fetchTasks'

export default (): void => {
  app.message(`sample get all tasks`, async ({ _message, say }): Promise<void> => {
    const taskTitles = await formattedText()
    await say(taskTitles)
  })
}

const formattedText = async (): Promise<string> => {
  let text: string = ''
  const bodyParameters = {
    filter: {
      property: 'status',
      select: {
        does_not_equal: 'DONE'
      }
    }
  }
  try {
    const results = await fetchTasks(bodyParameters)
    results.forEach((result) => {
      text = `${text}\nassignee: ${result.assignee}, startsAt: ${result.startsAt}, endsAt: ${result.startsAt}, status: ${result.status}, <${result.url}|${result.title}>`
    })
    return text
  } catch (error) {
    return 'something happened'
  }
}

import { app } from '../initializers/bolt'
import fetchTasks from '../functions/fetchTasks'
import { slackIdToNotionId } from '../functions/convertIds'

export default (): void => {
  app.message(`sample get my tasks`, async ({ message, say }): Promise<void> => {
    const userNotionId = await slackIdToNotionId(message.user)
    const taskTitles = await formattedText(userNotionId)
    
    await say(taskTitles)
  })
}

const formattedText = async (userNotionId: string): Promise<string> => {
  let text: string = ''
  const bodyParameters = {
    filter: {
      and: [
        {
          property: 'status',
          select: {
            does_not_equal: 'DONE'
          }
        },
        {
          property: 'Asignee',
          people: {
            contains: userNotionId
          }
        },
      ]
    }
  }
  try {
    const results = await fetchTasks(bodyParameters)
    results.forEach((result) => {
      text = `${text}\nassignee: ${result.assignee}, startsAt: ${result.startsAt}, endsAt: ${result.startsAt}, status: ${result.status}, <${result.url}|${result.title}>`
    })
    return text
  } catch (error) {
    return 'something happened'
  }
}