Read raffle candidate from dedicated channel (exclude orgs)

Author: fbiville

README.md

@@ -2,9 +2,12 @@
 
 ## Environment
 
- - `SLACK_TOKEN` envvar: Slack token including at least user read and email read permissions 
+ - `SLACK_TOKEN` envvar: Slack token including at least `groups:read`, `users:read` and `users:read.email` permissions.
  - `PORT` (optional, default: `3000`) envvar: HTTP port for the server to listen to
  - `PRIZE_FILE` (optional, default: `./samples/prizes.json`) envvar: static JSON file for prize data
+ - `ATTENDEE_CSV_FILE` envvar: static CSV file for alf.io attendee export
+
+Note that the corresponding bot should be invited to private channels before the token can be used to retrieve those.
 
 ## Getting started
 

index.js

@@ -1,32 +1,43 @@
 const {WebClient} = require('@slack/web-api');
 const {Raffle} = require('./lib/raffle');
-const RaffleCandidateRepository = require('./lib/raffle-candidate-repository');
 const RafflePrizeRepository = require('./lib/raffle-prize-repository');
 const express = require('express');
 const path = require('path');
 const fs = require('fs');
+const SlackChannelRepository = require("./lib/slack-channel-repository");
+const SlackUserRepository = require("./lib/slack-user-repository");
+const RaffleCandidateService = require("./lib/raffle-candidate-service");
 
-const token = process.env.SLACK_TOKEN;
-if (!token) {
-    throw new Error('Missing envvar SLACK_TOKEN');
+const readEnvOrFail = (key) => {
+    const result = process.env[key];
+    if (!result) {
+        throw new Error(`Missing envvar ${key}`);
+    }
+    return result;
 }
+
+const checkEnvVarPath = (path, envVar) => {
+    if (!fs.statSync(path).isFile()) {
+        throw new Error(`${path} does not point to a regular file. Please review your ${envVar} envvar configuration`);
+    }
+}
+
+const token = readEnvOrFail('SLACK_TOKEN');
+const attendeeCsvPath = readEnvOrFail('ATTENDEE_CSV_FILE');
+checkEnvVarPath(attendeeCsvPath, 'ATTENDEE_CSV_FILE');
 const port = process.env.PORT || 3000;
 const prizeFilePath = process.env.PRIZE_FILE || `${__dirname}/samples/prizes.json`;
-if (!fs.statSync(prizeFilePath).isFile()) {
-    throw new Error(`${prizeFilePath} does not point to a regular file. Please review your PRIZE_FILE envvar configuration`);
-}
+checkEnvVarPath(prizeFilePath, 'PRIZE_FILE');
 const app = express();
 app.use(express.json());
 
-const candidateRepository = new RaffleCandidateRepository(new WebClient(token));
+const slackClient = new WebClient(token);
 const prizeRepository = new RafflePrizeRepository(prizeFilePath);
+const raffleCandidateService = new RaffleCandidateService(new SlackChannelRepository(slackClient), new SlackUserRepository(slackClient));
 
 (async () => {
     const prizes = await prizeRepository.getPrizes();
-    const initialCandidates = await candidateRepository.getUsers((user) =>
-        !user.is_admin &&
-        !user.is_bot &&
-        user.id !== RaffleCandidateRepository.SLACKBOT_ID);
+    const initialCandidates = await raffleCandidateService.findInitialCandidates();
     const raffle = new Raffle(initialCandidates, prizes);
 
     app.get('/', (req, res) => {

lib/raffle-candidate-repository.js

@@ -0,0 +1,26 @@
+module.exports = class RaffleCandidateService {
+
+    constructor(slackChannelRepository, slackUserRepository) {
+        this._slackChannelRepository = slackChannelRepository;
+        this._slackUserRepository = slackUserRepository;
+    }
+
+    async findInitialCandidates() {
+        const orgIds = await this._findOrgIds();
+        const allCandidateIds = await this._findAllRaffleCandidateIds();
+        const eligibleParticipantIds = allCandidateIds.filter(candidateId => !orgIds.includes(candidateId));
+        return this._slackUserRepository.findAllByIds(eligibleParticipantIds)
+    }
+
+    async _findOrgIds() {
+        return this._slackChannelRepository.findOne('paris2021-org', true)
+            .then(channel => channel.id)
+            .then(channelId => this._slackUserRepository.findAllMemberIds(channelId))
+    }
+
+    async _findAllRaffleCandidateIds() {
+        return this._slackChannelRepository.findOne('paris2021-raffle', false)
+            .then(channel => channel.id)
+            .then(channelId => this._slackUserRepository.findAllMemberIds(channelId))
+    }
+}

lib/raffle-candidate-service.js

@@ -5,7 +5,7 @@ module.exports = class RafflePrizeFileRepository {
 
     constructor(prizeFile) {
         const rawPrizes = fs.readFileSync(prizeFile);
-        this._prizes = JSON.parse(rawPrizes).map((rawPrize) => new RafflePrize(rawPrize.description));
+        this._prizes = JSON.parse(rawPrizes.toString()).map((rawPrize) => new RafflePrize(rawPrize.description));
     }
 
     async getPrizes() {

lib/raffle-prize-repository.js

@@ -0,0 +1,28 @@
+module.exports = class SlackChannelRepository {
+
+    constructor(webClient) {
+        this._webClient = webClient;
+        this._cachedChannels = null;
+    }
+
+    async findOne(channelName, isPrivate = false) {
+        if (!this._cachedChannels || this._cachedChannels.private !== isPrivate) {
+            this._cachedChannels = {
+                private: isPrivate,
+                result: (await this._listChannels(isPrivate)).channels
+            };
+        }
+        return this._cachedChannels.result.find(channel => channel.name === channelName)
+    }
+
+    _listChannels(isPrivate) {
+        return this._webClient.conversations.list({types: this._channelType(isPrivate)});
+    }
+
+    _channelType(isPrivate) {
+        if (isPrivate) {
+            return 'private_channel'
+        }
+        return 'public_channel';
+    }
+}

lib/slack-channel-repository.js

@@ -0,0 +1,27 @@
+const {RaffleCandidate} = require('./raffle');
+
+module.exports = class SlackUserRepository {
+
+    constructor(webClient) {
+        this._webClient = webClient;
+        this._cachedUsers = null;
+    }
+
+    async findAllMemberIds(channelId) {
+        return await this._webClient.conversations.members({channel: channelId})
+            .then(response => response.members)
+    }
+
+    async findAllByIds(ids) {
+        return (await this._findMembers())
+            .filter(user => ids.includes(user.id))
+            .map((user) => new RaffleCandidate(user.id, user.real_name, user.profile.email, user.profile.image_192));
+    }
+
+    async _findMembers() {
+        if (!this._cachedUsers) {
+            this._cachedUsers = (await this._webClient.users.list()).members;
+        }
+        return this._cachedUsers;
+    }
+}

lib/slack-user-repository.js

@@ -3,8 +3,7 @@
   "version": "0.0.1",
   "description": "Raffle for https://hack-commit-pu.sh events",
   "main": "index.js",
-  "scripts": {
-  },
+  "scripts": {},
   "author": "Florent Biville <[email protected]>",
   "license": "Apache-2.0",
   "dependencies": {