firstSlackApp

SLACK_SIGNING_SECRET=<your-signing-secret>
export SLACK_SIGNING_SECRET
SLACK_BOT_TOKEN=xoxb-<your-bot-token>
export SLACK_BOT_TOKEN

const app = new App({
  token: process.env.SLACK_BOT_TOKEN,
  signingSecret: process.env.SLACK_SIGNING_SECRET,
  appToken: process.env.SLACK_APP_TOKEN,
  socketMode: true,
});

// "hello" を含むメッセージをリッスンします
app.message('hello', async ({ message, say }) => {
  // イベントがトリガーされたチャンネルに say() でメッセージを送信します
  await say(`Hey there <@${message.user}>!`);
});

(method) App.message(pattern: string | RegExp, ...listeners: MessageEventMiddleware[]): void (+4 overloads)
@param pattern
Used for filtering out messages that don't match. Strings match via String.prototype.includes.

@param listeners — Middlewares that process and react to the message events that matched the provided patterns.

$ node app.js
⚡️ Bolt app is running!

// "hello" を含むメッセージをリッスンします
app.message('hello', async ({ message, say }) => {
  // イベントがトリガーされたチャンネルに say() でメッセージを送信します
  await say({
    blocks: [
      {
        "type": "section",
        "text": {
          "type": "mrkdwn",
          "text": `Hey there <@${message.user}>!`
        },
        "accessory": {
          "type": "button",
          "text": {
            "type": "plain_text",
            "text": "Click Me"
          },
          "action_id": "button_click"
        }
      }
    ],
    text: `Hey there <@${message.user}>!`
  });
});

(parameter) say: SayFn
(message: string | SayArguments) => Promise<ChatPostMessageResponse>

    blocks: [
      {
        "type": "section",
        "text": {
          "type": "mrkdwn",
          "text": `Hey there <@${message.user}>!`
        },
        "accessory": {
          "type": "button",
          "text": {
            "type": "plain_text",
            "text": "Click Me"
          },
          "action_id": "button_click"
        }
      }
    ],

app.action('button_click', async ({ body, ack, say }) => {
  // アクションのリクエストを確認
  await ack();
  await say(`<@${body.user.id}> clicked the button`);
});

(method) App.action<SlackAction>(actionId: string | RegExp, ...listeners: Middleware<SlackActionMiddlewareArgs<SlackAction>>[]): void (+1 overload)

(parameter) ack: (response: void & Pick<ChatPostMessageArguments, "token" | "text" | "as_user" | "attachments" | "blocks" | "icon_emoji" | "icon_url" | "link_names" | "mrkdwn" | ... 5 more ... | "username"> & {
    ...;
} & DialogValidation) => Promise<...>

(parameter) body: SlackAction

// 勉強の開始時間 2022/01/22 09:30 を Unix エポックタイムで表示
const whenLearningStart = '1643157000';

app.message('wake me up', async ({ message, context, logger }) => {
  try {
    // トークンを用いて chat.scheduleMessage 関数を呼び出す
    const result = await app.client.chat.scheduleMessage({
      // アプリの初期化に用いたトークンを 'context' オブジェクトに保存
      token: context.botToken,
      channel: message.channel,
      post_at: whenLearningStart,
      text: 'Start learning'
    });
  }
  catch (error) {
    logger.error(error);
  }
});

const whenLearningStart = '1643330100';

{
  ok: true,
  scheduled_message_id: 'Q030YN7SJHF',
  channel: '***********',
  post_at: 1643331180,
  message: {
    bot_id: 'B02RG11KGEL',
    type: 'message',
    text: 'Start learning',
    user: '***********',
    team: '***********',
    bot_profile: {
      id: 'B02RG11KGEL',
      deleted: false,
      name: 'practice_make_slack_app',
      updated: 1639529612,
      app_id: 'A02QP9SNF5K',
      icons: [Object],
      team_id: ' ***********'
    }
  },
  response_metadata: {
    scopes: [
      'chat:write',
      'channels:history',
      'groups:history',
      'im:history',
      'mpim:history'
    ],
    acceptedScopes: [ 'chat:write' ]
  }
}

app.message('wake me up', async ({ message, context, logger }) => {
  try {
    // トークンを用いて chat.scheduleMessage 関数を呼び出す
    await app.client.chat.scheduleMessage({
      // アプリの初期化に用いたトークンを 'context' オブジェクトに保存
      token: context.botToken,
      channel: message.channel,
      post_at: whenLearningStart,
      text: 'Start learning'
    });
  }
  catch (error) {
    logger.error(error);
  }
});

// Require the Node Slack SDK package (github.com/slackapi/node-slack-sdk)
const { WebClient, LogLevel } = require("@slack/web-api");

// WebClient instantiates a client that can call API methods
// When using Bolt, you can use either `app.client` or the `client` passed to listeners.
const client = new WebClient("xoxb-your-token", {
  // LogLevel can be imported and used to make debugging simpler
  logLevel: LogLevel.DEBUG
});

// You probably want to use a database to store any user information ;)
let usersStore = {};

try {
  // Call the users.list method using the WebClient
  const result = await client.users.list();

  saveUsers(result.members);
}
catch (error) {
  console.error(error);
}

// Put users into the JavaScript object
function saveUsers(usersArray) {
  let userId = '';
  usersArray.forEach(function(user){
    // Key user info on their unique user ID
    userId = user["id"];
    
    // Store the entire user object (you may not need all of the info)
    usersStore[userId] = user;
  });
}

$ node app.js
/home/hoppers/first-bolt-app/app.js:78
  const result = await app.client.users.list();
                 ^^^^^

SyntaxError: await is only valid in async function
    at wrapSafe (internal/modules/cjs/loader.js:1001:16)
    at Module._compile (internal/modules/cjs/loader.js:1049:27)
    at Object.Module._extensions..js (internal/modules/cjs/loader.js:1114:10)
    at Module.load (internal/modules/cjs/loader.js:950:32)
    at Function.Module._load (internal/modules/cjs/loader.js:790:14)
    at Function.executeUserEntryPoint [as runMain] (internal/modules/run_main.js:76:12)
    at internal/main/run_main_module.js:17:47

app.message('Who are in this channel?', async ({ message, context, logger }) => {
  try {

    let members = app.client.users.list();
    console.log(members);

    await app.client.chat.postMessage{{
      token: context.botToken,
      channel: message.channel,
      text: {members},
    }}
  }
  catch (error) {
    logger.error(error);
  }
}

(async () => {
  const members = await app.client.users.list();
  console.log(members);
})();

{
  ok: true,
  members: [
    {
      id: 'USLACKBOT',
      team_id: '***********',
      name: 'slackbot',
      deleted: false,
      color: '757575',
      real_name: 'Slackbot',
      // 略
    },
    {
      id: '***********',
      team_id: '***********',
      name: '***********',
      deleted: false,
      color: '9f69e7',
      real_name: '***********',
      tz: 'Asia/Tokyo',
      // 略
    },
  ],
  cache_ts: 1643935502,
  response_metadata: {
    next_cursor: '',
    scopes: [
      'chat:write',
      'channels:history',
      'groups:history',
      'im:history',
      'mpim:history',
      'users:read'
    ],
    acceptedScopes: [ 'users:read' ]
  }
}

app.message('who is in channnel?', async ({ say, logger }) => {
  try {
    let members = await app.client.users.list();

    await say({
      blocks: [
        {
          "type": "section",
          "text": {
            "type": "mrkdwn",
            "text": `Hey there <${members}>!`
          },
        }
      ],
      text: `Hey there <${members}>!`
    });
  }
  catch (error) {
    logger.error(error);
  }
});

let userNames = {};

app.message('who is in channnel?', async ({ say, logger }) => {
  try {
    let users = await app.client.users.list();
    userNames = retrieveUsersName(users.members);

    await say({
      blocks: [
        {
          "type": "section",
          "text": {
            "type": "mrkdwn",
            "text": `Hey there <${userNames}>!`
          },
        }
      ],
      text: `Hey there <${userNames}>!`
    });
  }
  catch (error) {
    logger.error(error);
  }
});

// Put User names into the Objext
function retrieveUsersName(usersArray) {
  let userName = '';

  usersArray.forEach(function(user) {
    userName = user["name"];


  });
}

function retrieveUsersName(usersArray) {
  usersArray.forEach(function(user) {
    userNames.unshift(user['name']);
  });
}

function retrieveUserNames(usersArray) {
  usersArray.forEach(function(user) {
    userNames += user['name'] + ', ';
  });
}

  usersArray.forEach(function(user) {
    userNames += user['name'] + ', ';
    console.log(userNames);
  });

slackbot,
slackbot, hirose,
slackbot, hirose, practicemakeslackapp,

function retrieveUserNames(usersArray) {
  usersArray.forEach(function(user) {
    userNames += user['name'] + ', ';
  });
  return userNames;
}

// Unix timestamp for tomorrow morning at 9AM
const tomorrow = new Date();
tomorrow.setDate(tomorrow.getDate() + 1);
tomorrow.setHours(9, 0, 0);

// Channel you want to post the message to
const channelId = "C12345";

try {
  // Call the chat.scheduleMessage method using the WebClient
  const result = await client.chat.scheduleMessage({
    channel: channelId,
    text: "Looking towards the future",
    // Time to post message, in Unix Epoch timestamp format
    post_at: tomorrow.getTime() / 1000
  });

  console.log(result);
}
catch (error) {
  console.error(error);
}

/** Enables basic storage and retrieval of dates and times. */
interface Date {
    // 中略
    getUTCDate(): number;
    /** Gets the day of the week, using local time. */
    getDay(): number;
    /** Gets the day of the week using Universal Coordinated Time (UTC). */
    // 中略
}

console.log(new Date().getUTCDate()); // 15

console.log(new Date().getUTCDay());

$ node app.js 
3
⚡️ Bolt app is running!

dateOfWeek = new Date().getUTCDay();

if ( dateOfWeek = 4) {
  // 日時を設定
  dateOfWeek.setDate(dateOfWeek.getDate());
  dateOfWeek.setHours(9, 5 ,0);
  console.log(dateOfWeek.getTime() / 1000);

  // const channelId = "";

  // メッセージを送信
}

TypeError: dateOfWeek.getDate is not a function

date = new Date();

// 曜日を取得
dateOfWeek = date.getUTCDay();

// 指定曜日ならメッセージを送信
if ( dateOfWeek = 4) {
  // 日時を設定
  date.setDate(date.getDate());
  date.setHours(9, 5 ,0);
  console.log(date.getTime() / 1000);

  // const channelId = "";

  // メッセージを送信

}

    try {
      const result = await app.client.chat.scheduleMessage({
        channel: channelId,
        text: "Today is Wed.",
        post_at: date.getTime() / 1000,
      });

      console.log(result);
    }
    catch(error) {
      console.error(error);
    }

SyntaxError: await is only valid in async functions and the top level bodies of modules

  async () => {
    try {
      const result = await app.client.chat.scheduleMessage({
        channel: channelId,
        text: "Today is Wed.",
        post_at: date.getTime() / 1000,
      });

      console.log(result);
    }
    catch(error) {
      console.error(error);
    }
  }

post_at: date.getTime() / 1000,

import { Date } from "./node_modules/typescript/lib/lib.es5.d.ts";

{
  "compilerOptions": {
    "target": "ES5",
    "lib": ["ES2020", "DOM"],
    "module": "ES2015",
}

date = new Date();
console.log(date.getDate());

const date = new Date();
console.log(date); // 2022-05-20T01:00:20.931Z
const dateOfWeek = date.getDay();
console.log(dateOfWeek); // 5

date.setHours(11, 50, 0);
console.log(date); // 2022-05-20T02:50:00.931Z

trigger = date.setUTCHours(09, 50, 0);
console.log(trigger / 1000);

trigger = date.setUTCHours(00, 50, 0);
console.log(trigger / 1000); // 1653267000.082 -> 2022/05/23 9:50

const date = new Date();
const dateOfWeek = date.getDay();
console.log(dateOfWeek);

// 指定曜日ならメッセージを送信
if (dateOfWeek = 4) {
  // 日時を設定
  const trigger_time = date.setUTCHours(00, 50, 0);
  console.log(trigger_time / 1000);

  // channelId を定義
  const channelId = "**********";

  // メッセージを送信
  async () => {
    try {
      const result = await app.client.chat.scheduleMessage({
        channel: channelId,
        text: "Today is Thu.",
        post_at: trigger_time,
      });

      console.log(result);
    }
    catch(error) {
      console.error(error);
    }
  }
}

  const trigger_time = date.setUTCHours(00, 50, 0);
  console.log(trigger_time / 1000);

  const trigger_time = date.setUTCHours(01, 05, 0) / 1000;

const trigger_time = Math.trunc(date.setUTCHours(10, 00, 0) / 1000); // 1653991200

{
    "ok": false,
    "error": "invalid_auth"
}

{
    "ok": true,
    "scheduled_message_id": "********",
    "channel": "************",
    "post_at": 1655945100,
    "message": {
        "bot_id": "******,
        "type": "message",
        "text": "Today is Thr.",
        "bot_profile": {
            // 略
            },
            "team_id": "*********"
        },
        "blocks": [
            {
                "type": "rich_text",
                "block_id": "Lw0dv",
                "elements": [
                    {
                        "type": "rich_text_section",
                        "elements": [
                            {
                                "type": "text",
                                "text": "Today is Thr."
                            }
                        ]
                    }
                ]
            }
        ]
    }
}

const { WebClient, LogLevel } = require("@slack/web-api");

const client = new WebClient(process.env.SLACK_BOT_TOKEN, {
  // LogLevel can be imported and used to make debugging simpler
  logLevel: LogLevel.DEBUG
});

(async () => {
  const result = await client.chat.postMessage({
    text: 'WebClient test.',
    channel: conversationId,
  });
})

(async () => {
  // 
}}();

$ node app.js 
[DEBUG]  web-api:WebClient:0 initialized
[DEBUG]  web-api:WebClient:0 apiCall('chat.postMessage') start
[DEBUG]  web-api:WebClient:0 will perform http request

if ( dateOfWeek === 5) {
  // 日時を設定
  const trigger_time = Math.trunc(date.setUTCHours(00, 55, 0) / 1000);
  console.log(trigger_time);

  // channelId を定義
  const channelId = "**************";

  // メッセージを送信
  (async () => {
    try {
      const result = await client.chat.scheduleMessage({
        channel: channelId,
        text: "Today is Fri.",
        post_at: trigger_time,
      });

      console.log(result);
    }
    catch(error) {
      console.error(error);
    }
  })();
}

$ node app.js 
[DEBUG]  web-api:WebClient:0 initialized
[DEBUG]  web-api:WebClient:0 apiCall('chat.scheduleMessage') start
[DEBUG]  web-api:WebClient:0 will perform http request
⚡️ Bolt app is running!
[DEBUG]  web-api:WebClient:0 http response received
{
  ok: true,
  scheduled_message_id: '***********',
  channel: '***************',
  post_at: 1656032100,
  message: {
    bot_id: '**********************,
    type: 'message',
   //
    },
    blocks: [ [Object] ]
  },
  response_metadata: {
    scopes: [
      'chat:write',
      'channels:history',
      'groups:history',
      'im:history',
      'mpim:history',
      'users:read'
    ],
    acceptedScopes: [ 'chat:write' ]
  }
}

{
	"blocks": [
		{
			"type": "actions",
			"block_id": "actions1",
			"elements": [
				{
					"type": "section",
					"block_id": "section678",
					"text": {
						"type": "mrkdwn",
						"text": "Pick users from the list"
					},
					"accessory": {
						"action_id": "text1234",
						"type": "multi_users_select",
						"placeholder": {
							"type": "plain_text",
							"text": "Select users"
						}
					}
				},
				{
					"type": "button",
					"text": {
						"type": "plain_text",
						"text": "Cancel"
					},
					"value": "cancel",
					"action_id": "button_1"
				}
			]
		}
	]
}

{
	"blocks": [
		{
			"type": "section",
			"text": {
				"type": "mrkdwn",
				"text": "毎週月曜は *フィードバックリクエスト* を送る日だよ\n今回は誰にフィードバックをもらおうか？\nメンバーから *3 人* 以上選んでね"
			}
		},
		{
			"type": "divider"
		}
	]
}

		{
			"type": "input",
			"label": "plain_text",
			"options": [
				{
					"value": "A",
					"text": {
						"type": "plain_text",
						"text": "checkbox 1"
					}
				},
				{
					"value": "B",
					"text": {
						"type": "plain_text",
						"text": "checkbox 2"
					}
				}
			],
			"element": {
				"type": "checkboxes",
				"action_id": "this_is_an_action_id"
			},
			"initial_options": [
				{
					"value": "A1",
					"text": {
						"type": "plain_text",
						"text": "Checkbox 1"
					}
				}
			]
		}

{
	"blocks": [
		{
			"type": "input",
			"label": {
				"type": "plain_text",
				"text": "メンバーを 3 人以上選んでね",
				"emoji": true
			},
			"element": {
				"type": "checkboxes",
				"action_id": "this_is_an_action_id",
				"options": [
					{
						"value": "member_id_1",
						"text": {
							"type": "plain_text",
							"text": "リーダー"
						}
					},
					{
						"value": "member_id_2",
						"text": {
							"type": "plain_text",
							"text": "メンバーさん"
						}
					}
				]
			}
		}
	]
}

{
	"blocks": [
		{
			"type": "input",
			"label": {
				"type": "plain_text",
				"text": "メンバーを 3 人以上選んでね",
				"emoji": true
			},
			"element": {
				"action_id": "this_is_an_action_id",
				"type": "users_select",
				"placeholder": {
					"type": "plain_text",
					"text": "メンバーは3人以上"
				}
			}
		}
	]
}

{
	"blocks": [
		{
			"type": "input",
			"label": {
				"type": "plain_text",
				"text": "メンバーを 3 人以上選んでね",
				"emoji": true
			},
			"element": {
				"action_id": "select_member",
				"type": "multi_users_select",
				"placeholder": {
					"type": "plain_text",
					"text": "メンバーは5人まで選べるよ"
				},
				"max_selected_items": 5
			}
		}
	]
}

// Require the Node Slack SDK package (github.com/slackapi/node-slack-sdk)
const { WebClient, LogLevel } = require("@slack/web-api");

// WebClient instantiates a client that can call API methods
// When using Bolt, you can use either `app.client` or the `client` passed to listeners.
const client = new WebClient("xoxb-your-token", {
  // LogLevel can be imported and used to make debugging simpler
  logLevel: LogLevel.DEBUG
});
const { App } = require('@slack/bolt');

const app = new App({
  token: process.env.BOT_TOKEN,
  appToken: process.env.SLACK_APP_TOKEN,
  socketMode: true,
});

(async () => {
  await app.start();
  console.log('⚡️ Bolt app started');
})();

curl -X POST "https://slack.com/api/apps.connections.open" \
-H "Content-type: application/x-www-form-urlencoded" \
-H "Authorization: Bearer xapp-1-123"

-H "Authorization: Bearer xapp-1-123"

$ curl -X POST "https://slack.com/api/apps.connections.open" \
> -H "Content-type: application/x-www-form-urlencoded" \
> -H "Authorization: Bearer xapp-1-2345"
{"ok":true,"url":"wss:\/\/wss-primary.slack.com\/link\/?ticket=12345&app_id=abcd"}

if (response.ok) {
  let wssUrl = response.url;
  let socket = new WebSocket(wssUrl);

  socket.onopen = function(e) {
    // connection established
  }

  socket.onmessage = function(event) {
    // application received message
  }
}

fetch('https://slack.com/api/apps.connections.open', {
  headers: {
    Accept: "Content-type: application/x-www-form-urlencoded",
    Authorization: "Bearer " + process.env.SLACK_APP_TOKEN,
  }
}).then(response => {
  if (response.ok) {
    let wssUrl = response.url;
    // let socket = new WebSocket(wssUrl);

    console.log(wssUrl);

    /*
    socket.onopen = function(e) {
      // connection established
    }

    socket.onmessage = function(event) {
      // application received message
    }
    */
  }
  throw new Error('Network response was not ok.');
})

fetch('https://slack.com/api/apps.connections.open', {
^

ReferenceError: fetch is not defined
    at Object.<anonymous> (/home/hoppers/first-bolt-app/app.js:122:1)
    at Module._compile (node:internal/modules/cjs/loader:1103:14)
    at Object.Module._extensions..js (node:internal/modules/cjs/loader:1155:10)
    at Module.load (node:internal/modules/cjs/loader:981:32)
    at Function.Module._load (node:internal/modules/cjs/loader:822:12)
    at Function.executeUserEntryPoint [as runMain] (node:internal/modules/run_main:77:12)
    at node:internal/main/run_main_module:17:47

  (async () => {
    try {
      const result = await client.chat.scheduleMessage({
        blocks: [
          {
            "type": "header",
            "text": {
              "type": "plain_text",
              "text": "Request Feedback",
              "emoji": true
            }
          },
          {
            "type": "divider"
          },
          {
            "type": "section",
            "text": {
              "type": "mrkdwn",
              "text": "*Today is a Feedback Day!* Select members you want feedback from."
            }
          },
          {
            "type": "input",
            "element": {
              "type": "multi_users_select",
              "placeholder": {
                "type": "plain_text",
                "text": "Select users",
                "emoji": true
              },
              "action_id": "multi_users_select_action"
            },
            "label": {
              "type": "plain_text",
              "text": "フィードバックを依頼するメンバーを 3 人以上選んでね",
              "emoji": true
            }
          },
          {
            "type": "actions",
            "elements": [
              {
                "type": "button",
                "text": {
                  "type": "plain_text",
                  "text": "フィードバックを依頼する :Envelope:",
                  "emoji": true
                },
                "value": "requests",
                "action_id": "feedback_requests"
              }
            ]
          }
        ],
        channel: channelId,
        post_at: trigger_time,
      });

      console.log(result);
    }
    catch(error) {
      console.error(error);
    }
  })();

app.action("multi_users_select-action", async({ ack, body }) => {
  await ack();
  console.log(body);
});

$ node app.js 
[DEBUG]  web-api:WebClient:0 initialized
:
:
[DEBUG]  web-api:WebClient:0 apiCall('chat.scheduleMessage') start
[WARN]  web-api:WebClient:0 The `text` argument is missing in the request payload for a chat.scheduleMessage call - It's a best practice to always provide a `text` argument when posting a message. The `text` is used in places where the content cannot be rendered such as: system push notifications, assistive technology such as screen readers, etc.
:
:
[ERROR]  web-api:WebClient:0 missing required field: text
Error: An API error occurred: invalid_arguments
    at platformErrorFromResult (/home/user/first-bolt-app/node_modules/@slack/web-api/dist/errors.js:51:33)
    at WebClient.apiCall (/home/user/first-bolt-app/node_modules/@slack/web-api/dist/WebClient.js:167:56)
    at processTicksAndRejections (node:internal/process/task_queues:96:5)
    at async /home/hoppers/first-bolt-app/app.js:108:22 {
  code: 'slack_webapi_platform_error',
  data: {
    ok: false,
    error: 'invalid_arguments',
    response_metadata: { messages: [Array], scopes: [Array], acceptedScopes: [Array] }
  }
}

{
  type: 'block_actions',
  user: {
    id: '****************',
    username: '****',
    name: '****',
  },
  container: {
    type: 'message',
    is_ephemeral: false
  },
  team: { id: '******', domain: 'sandboxapi' },
  channel: { id: '******', name: 'general' },
  message: {
    bot_id: 'B02RG11KGEL',
    type: 'message',
    text: 'Woops, something wrong.',
    blocks: [ [Object], [Object], [Object], [Object], [Object] ]
  },
  actions: [
    {
      type: 'multi_users_select',
      action_id: 'multi_users_select-action',
      block_id: 'DIr4',
      selected_users: [Array],
      action_ts: '1661993163.947008'
    }
  ]
}

app.action("feedback_requests", async({ body, ack, say }) => {
  await ack();
  console.log(body);
  await say("フィードバックのリクエスト受け取りました！")
});

{
	"blocks": [
		{
			"type": "header",
			"text": {
				"type": "plain_text",
				"text": "フィードバックをリクエストしよう！",
				"emoji": true
			}
		},
		{
			"type": "section",
			"text": {
				"text": "今日はフィードバックをリクエストする日です。\nフィードバックをもらいたいメンバーを *3 名* 以上選んでください。",
				"type": "mrkdwn"
			},
			"accessory": {
				"type": "multi_users_select",
				"action_id": "selected_users",
				"placeholder": {
					"type": "plain_text",
					"text": "メンバーを選ぶ"
				}
			}
		}
	]
}

      const result = await client.chat.scheduleMessage({
        channel: channelId,
        post_at: trigger_time,
        text: "Woops, something wrong.",
        blocks: [
          {
            "type": "header",
            "text": {
              "type": "plain_text",
              "text": "フィードバックをリクエストしよう！",
              "emoji": true
            }
          },
          {
            "type": "divider"
          },
          {
            "type": "section",
            "text": {
              "text": "今日はフィードバックをリクエストする日です。\nフィードバックをもらいたいメンバーを *3 名* 以上選んでください。",
              "type": "mrkdwn"
            },
            "accessory": {
              "type": "multi_users_select",
              "action_id": "selected_users",
              "placeholder": {
                "type": "plain_text",
                "text": "メンバーを選ぶ"
              }
            }
          }
        ],
      });

{
  type: 'multi_users_select',
  action_id: 'selected_users',
  block_id: '****',
  selected_users: [ 'U02Q******, 'U02Q******' ],
  action_ts: '*******************'
}

app.action("selected_users", async({ body, ack, say }) => {
  await ack();
  console.log(body["user"];
  console.log(body["actions"][0]["selected_users"]);
  await say("フィードバックのリクエスト受け取りました！")
  // await respond('フィードバックを依頼する相手は <@${action.}>')
});

{
  id: 'U02Q********',
  username: '*****',
  name: '*****',
  team_id: '*******'
}
[ 'U02Q********, 'U02Q*******' ]

app.action("selected_users", async({ body, ack, respond }) => {
  await ack();
  const selected_users_id = body["actions"][0]["selected_users"];
  await selected_users_id.forEach(selected_user_id => {
    const user = client.users.info({
      user: selected_user_id
    });
    respond(`フィードバックを依頼した相手は <@${user.user.name}> さんですね`);
});

Promise { <pending> }

app.action("selected_users", async({ body, ack, say, respond }) => {
  await ack();
  const selected_users_id = body["actions"][0]["selected_users"];
  await selected_users_id.forEach(async (selected_user_id) => {
    const user = await client.users.info({
      user: selected_user_id
    });
    await respond(`フィードバックを依頼した相手は <@${user.user.name}> さんですね`);
    console.log(user.user.name);
  });
});

practicemakeslackapp
****se

app.action("selected_users", async({ body, ack, respond }) => {
  await ack();
  const selected_users_id = body["actions"][0]["selected_users"];
  await selected_users_id.forEach(async (selected_user_id) => {
    const user = await client.users.info({
      user: selected_user_id
    });
    await respond(`フィードバックを依頼した相手は <@${user.user.name}> さんですね`);
    console.log(user.user.name);

    try {
      const result = await client.chat.postMessage({
        channel: user.user.id,
        text: "テストメッセージだよ"
      });
      console.log(result);
    }
    catch (error) {
      console.log(error);
    }
  });
});

  await selected_users_id.forEach(async (selected_user_id) => {
    const user = await client.users.info({
      user: selected_user_id
    });
    console.log(user.user.name);
    await say(`フィードバックを依頼した相手は <@${user.user.name}> さんですね`);

    try {
      const result = await client.chat.postMessage({
        channel: user.user.id,
        text: "テストメッセージだよ"
      });
      console.log(result);
    }
    catch (error) {
      console.log(error);
    }
  });

app.action("selected_users", async ({ body, ack, say }) => {
  await ack();
  const requested_user = body.user.username;
  // 中略

    try {
      const result = await client.chat.postMessage({
        channel: user.user.id,
        text: `<@${requested_user}> さんからのテストメッセージだよ`
      });
      console.log(result);
    }
    catch (error) {
      console.log(error);
    }
  });
});

signingSecret: "your-signing-secret",

app.action("open_modal", async ({ body, ack, client, logger}) => {
  await ack();

  try {
    const result = await client.views.open({
      trigger_id: body.trigger_id,
      view: {
        type: 'modal',
        callback_id: "intial_view",
        title: {
          type: "plain_text",
          text: "フィードバック入力フォーム"
        }
      },
    });
    logger.info(result);
  } catch (error) {
    logger.info(error);
  }
});

app.action("open_modal", async ({ body, ack, client, logger}) => {
  await ack();

  try {
    const result = await client.views.open({
      trigger_id: body.trigger_id,
      view: {
        type: 'modal',
        callback_id: "intial_view",
        title: {
          type: "plain_text",
          text: "フィードバック入力フォーム"
        },
        submit: {
          type: "plain_text",
          text: "送信",
          emoji: true
        },
        blocks: [
          {
            type: "section",
            text: {
              type: "mrkdwn",
              text: "フィードバックを受け取ると、 *自信* に繋がり、新しい *チャレンジ* を生み出すので、ぜひご協力をお願いします :pray:"
            }
          },
          {
            type: "divider"
          },
          {
            type: "section",
            text: {
              type: "mrkdwn",
              text: "フィードバックする相手を選んでください"
            },
            accessory: {
              type: "users_select",
              placeholder: {
                type: "plain_text",
                text: "メンバー",
                emoji: true
              },
              action_id: "users_select-action"
            }
          },
          {
            type: "input",
            element: {
              type: "plain_text_input",
              multiline: true,
              action_id: "keep_input-action"
            },
            "label": {
              type: "plain_text",
              text: "｢いいな｣と思うところや見習いたいところを挙げてください",
              emoji: true
            }
          },
          {
            type: "input",
            element: {
              type: "plain_text_input",
              multiline: true,
              action_id: "problem_input-action"
            },
            "label": {
              type: "plain_text",
              text: "ここを変えるともっといいなと思うところを挙げてください",
              emoji: true
            }
          }
        ]
      },
    });
    logger.info(result);
  } catch (error) {
    logger.info(error);
  }
});

app.view('view_b', async ({ ack, body, view, client, logger }) => {
  // 処理
});

// modal の view.open() に callback_id を post_feedback を追加
app.action("open_modal",  async ({ body, ack, client, logger}) => {
  console.log(body);
});

// 入力フォームを開く
app.action("open_modal", async ({ body, ack, client, logger}) => {
  await ack();

  try {
    const result = await client.views.open({
      trigger_id: body.trigger_id,
      view: {
        type: 'modal',
        callback_id: "post_feedback",
        title: {
          type: "plain_text",
          text: "フィードバック入力フォーム"
        },
        submit: {
          type: "plain_text",
          text: "送信",
          emoji: true
        },
        close: {
          type: "plain_text",
          text: "あとで入力する",
        },
        blocks: [
          {
            type: "section",
            text: {
              type: "mrkdwn",
              text: "フィードバックを受け取ると、 *自信* に繋がり、新しい *チャレンジ* を生み出すので、ぜひご協力をお願いします :pray:"
            }
          },
          {
            type: "divider"
          },
          {
            type: "input",
            block_id: "select_user",
            element: {
              type: "users_select",
              placeholder: {
                type: "plain_text",
                text: "メンバー",
                emoji: true
              },
              action_id: "feedback_user"
            },
            label: {
              type: "plain_text",
              text: "フィードバックする相手を選んでください",
              emoji: true
            }
          },
          {
            type: "input",
            block_id: "keep_value",
            element: {
              type: "plain_text_input",
              multiline: true,
              action_id: "keep_input"
            },
            label: {
              type: "plain_text",
              text: "｢いいな｣と思うところや見習いたいところを挙げてください",
              emoji: true
            }
          },
          {
            type: "input",
            block_id: "problem_value",
            element: {
              type: "plain_text_input",
              multiline: true,
              action_id: "problem_input"
            },
            label: {
              type: "plain_text",
              text: "ここを変えるともっといいなと思うところを挙げてください",
              emoji: true
            }
          }
        ]
      },
    });
    logger.info(result);
  } catch (error) {
    logger.info(error);
  }
});

// フィードバックが入力されたらフィードバック結果をメッセージする
app.view('post_feedback', async ({ ack, body, view, client, logger }) => {
  await ack();

  const feedback_reciever = view.state.values.select_user.feedback_user.selected_user;
  const keep_value = view.state.values.keep_value.keep_input.value;
  const problem_value = view.state.values.problem_value.problem_input.value;
  const feedback_sender = body['user']['name'];
  const feedback_sender_id = body['user']['id'];

  try {
    const result_message_feedback_reciever = await client.chat.postMessage({
      channel: feedback_reciever,
      text: "Woops, something wrong.",
      blocks: [
        {
          "type": "header",
          "text": {
            "type": "plain_text",
            "text": `<@${feedback_sender}> さんからフィードバックが届きました`,
            "emoji": true
          }
        },
        {
          "type": "divider"
        },
        {
          "type": "section",
          "text": {
            "type": "mrkdwn",
            "text": ":one: *｢いいな｣と思うところや見習いたいところ*"
          }
        },
        {
          "type": "section",
          "text": {
            "type": "plain_text",
            "text": keep_value
          }
        },
        {
          "type": "divider"
        },
        {
          "type": "section",
          "text": {
            "type": "mrkdwn",
            "text": ":two: *ここを変えるともっといいなと思うところ*"
          }
        },
        {
          "type": "divider"
        },
        {
          "type": "section",
          "text": {
            "type": "plain_text",
            "text": problem_value
          }
        }
      ]
    });
    logger.error(result_message_feedback_reciever);
  }
  catch (error) {
    logger.error(error)
  };

  try {
    const result_message_feedback_sender = await client.chat.postMessage({
      channel: feedback_sender_id,
      text: `<@${feedback_reciever}> さんにフィードバックしました`
    });
    logger.error(result_message_feedback_sender);
  }
  catch (error) {
    logger.error(error)
  };
});

$ sudo npm install --save node-cron

up to date, audited 162 packages in 620ms

37 packages are looking for funding
  run `npm fund` for details

found 0 vulnerabilities

let cron = require('node-cron');

cron.schedule('* * * * * *', () => {
  console.log('running a task every minute.');
});

$ node app.js 
[DEBUG]  web-api:WebClient:0 initialized
1
⚡️ Bolt app is running!
running a task every minute.
running a task every minute.
running a task every minute.
running a task every minute.
running a task every minute.
running a task every minute.

cron.schedule('00 50 09 * * 1', () => {
  console.log('today is Monday.');
}, {
  timezone: "Asia/Tokyo"
});

$ node app.js 
[DEBUG]  web-api:WebClient:0 initialized
1
⚡️ Bolt app is running!
today is Monday.

cron.schedule('00 50 09 * * 1', () => {
  (async () => {
    try {
      const result = await client.chat.scheduleMessage({
        channel: channelId,
        post_at: trigger_time,
        text: "Woops, something wrong.",
        blocks: [
          {
            "type": "header",
            "text": {
              "type": "plain_text",
              "text": "フィードバックをリクエストしよう！",
              "emoji": true
            }
          },
          {
            "type": "divider"
          },
          {
            "type": "section",
            "text": {
              "text": "今日はフィードバックをリクエストする日です。\nフィードバックをもらいたいメンバーを *3 名* 以上選んでください。",
              "type": "mrkdwn"
            },
            "block_id": "request_feedback",
            "accessory": {
              "type": "multi_users_select",
              "action_id": "selected_users",
              "placeholder": {
                "type": "plain_text",
                "text": "メンバーを選ぶ"
              }
            }
          }
        ],
      });
      console.log(result);
    }
    catch(error) {
      console.error(error);
    }
  })();
}, {
  timezone: "Asia/Tokyo"
});