serverless-ircd 0.6.0 → 0.7.0

package/apps/web/upstream/src/components/Captcha.vue

@@ -0,0 +1,85 @@
+<template>
+    <div>
+        <div v-if="showCaptcha" ref="captchacontainer" />
+    </div>
+</template>
+
+<script>
+
+'kiwi public';
+
+export default {
+    props: ['network'],
+    data() {
+        return {
+            recaptchaUrl: '',
+            recaptchaSiteId: '',
+            recaptchaResponse: '',
+            showCaptcha: false,
+        };
+    },
+    created() {
+        let options = this.$state.settings.startupOptions;
+        this.recaptchaSiteId = options.recaptchaSiteId || '';
+        this.recaptchaUrl = options.recaptchaUrl || 'https://www.google.com/recaptcha/api.js';
+
+        this.listen(this.$state, 'network.connecting', (event) => {
+            event.network.ircClient.once('socket connected', () => {
+                if (this.recaptchaResponse) {
+                    event.network.ircClient.raw('CAPTCHA', this.recaptchaResponse);
+                }
+            });
+        });
+
+        this.listen(this.$state, 'irc.raw.CAPTCHA', (command, event, network) => {
+            if (network !== this.network) {
+                return;
+            }
+
+            if (event.params[0] === 'NEEDED') {
+                this.loadRecaptcha();
+            }
+        });
+    },
+    methods: {
+        loadRecaptcha() {
+            if (window.grecaptcha) {
+                this.recaptchaShow();
+                return;
+            }
+
+            // Recaptcha calls this callback once it's loaded and ready to be used
+            window.recaptchaLoaded = () => {
+                this.recaptchaShow();
+            };
+
+            let scr = document.createElement('script');
+            scr.src = this.recaptchaUrl + '?onload=recaptchaLoaded&render=explicit';
+            scr.defer = true;
+            document.head.appendChild(scr);
+        },
+        recaptchaShow() {
+            this.showCaptcha = true;
+            this.$nextTick(() => {
+                window.grecaptcha.render(this.$refs.captchacontainer, {
+                    'sitekey': this.recaptchaSiteId,
+                    'callback': this.recaptchaSuccess,
+                    'expired-callback': this.recaptchaExpired,
+                });
+            });
+        },
+        recaptchaSuccess(response) {
+            this.recaptchaResponse = response;
+
+            // If we have a network instance already, send the captcha response
+            if (this.network && this.network.state === 'connecting') {
+                this.network.ircClient.raw('CAPTCHA', response);
+            }
+            this.showCaptcha = false;
+        },
+        recaptchaExpired() {
+            this.recaptchaResponse = '';
+        },
+    },
+};
+</script>

package/apps/web/upstream/src/components/ChannelBanlist.vue

@@ -0,0 +1,96 @@
+<template>
+    <div class="kiwi-channelbanlist">
+        <form class="u-form kiwi-channelbanlist" @submit.prevent="">
+            <a class="u-link" @click="updateBanlist">{{ $t('bans_refresh') }}</a>
+
+            <table v-if="banlist.length > 0" class="kiwi-channelbanlist-table">
+                <tr>
+                    <th>{{ $t('bans_user') }}</th>
+                    <th />
+                    <th />
+                </tr>
+                <tr v-for="ban in banlist" :key="ban.banned" :title="'By ' + ban.banned_by">
+                    <td class="kiwi-channelbanlist-table-mask">{{ ban.banned }}</td>
+                    <td class="kiwi-channelbanlist-table-bannedat">
+                        {{ (new Date(ban.banned_at * 1000)).toDateString() }}
+                    </td>
+                    <td class="kiwi-channelbanlist-table-actions">
+                        <i class="fa fa-trash" aria-hidden="true" @click="removeBan(ban.banned)" />
+                    </td>
+                </tr>
+            </table>
+            <div v-else-if="is_refreshing">
+                {{ $t('bans_refreshing') }}
+            </div>
+            <div v-else class="kiwi-channelbanlist-empty">
+                {{ $t('bans_nobody') }}
+            </div>
+        </form>
+    </div>
+</template>
+
+<script>
+'kiwi public';
+
+export default {
+    props: ['buffer'],
+    data: function data() {
+        return {
+            banlist: [],
+            is_refreshing: false,
+        };
+    },
+    created: function created() {
+        this.updateBanlist();
+    },
+    methods: {
+        updateBanlist: function updateBanlist() {
+            if (this.buffer.getNetwork().state !== 'connected' || this.is_refreshing) {
+                return;
+            }
+
+            let channelName = this.buffer.name;
+            this.is_refreshing = true;
+            this.buffer.getNetwork().ircClient.banlist(channelName, (banEvent) => {
+                this.banlist = banEvent.bans;
+                this.is_refreshing = false;
+            });
+        },
+        removeBan: function removeBan(mask) {
+            let channelName = this.buffer.name;
+            this.buffer.getNetwork().ircClient.unban(channelName, mask);
+            this.banlist = this.banlist.filter((ban) => ban.banned !== mask);
+        },
+    },
+};
+</script>
+
+<style lang="less">
+.kiwi-channelbanlist-table {
+    width: 100%;
+    border-collapse: collapse;
+    line-height: 20px;
+    margin-top: 10px;
+}
+
+.kiwi-channelbanlist-table tr {
+    border-bottom: 1px solid;
+}
+
+.kiwi-channelbanlist-table-mask {
+    word-break: break-all;
+}
+
+.kiwi-channelbanlist-table-bannedat {
+    min-width: 150px;
+}
+
+.kiwi-channelbanlist-table-actions {
+    min-width: 50px;
+    text-align: center;
+    cursor: pointer;
+    position: relative;
+    transition: all 0.3s;
+    z-index: 1;
+}
+</style>

package/apps/web/upstream/src/components/ChannelInfo.vue

@@ -0,0 +1,159 @@
+<template>
+    <div class="kiwi-channelinfo">
+        <form class="u-form kiwi-channelinfo-basicmodes" @submit.prevent="">
+            <label class="kiwi-channelinfo-topic">
+                <span>{{ $t('channel_topic') }}</span>
+                <textarea v-model.lazy="topic" rows="2" />
+            </label>
+
+            <div v-if="buffer.topics.length > 1" class="kiwi-channelinfo-previoustopics">
+                <a class="u-link" @click="showPrevTopics = !showPrevTopics">
+                    Previous topics
+                    <i :class="'fa fa-caret-' + (showPrevTopics ? 'up' : 'down')" />
+                </a>
+                <ul v-if="showPrevTopics">
+                    <li v-for="(topicText, idx) in prevTopics" :key="idx">
+                        <span>{{ topicText.trim() }}</span>
+                    </li>
+                </ul>
+            </div>
+
+            <label class="u-checkbox-wrapper">
+                <span>{{ $t('channel_moderated') }}</span>
+                <input v-model="modeM" type="checkbox">
+            </label>
+            <label class="u-checkbox-wrapper">
+                <span>{{ $t('channel_invite') }}</span>
+                <input v-model="modeI" type="checkbox">
+            </label>
+            <label class="u-checkbox-wrapper">
+                <span>{{ $t('channel_secret') }}</span>
+                <input v-model="modeS" type="checkbox">
+            </label>
+            <label class="u-checkbox-wrapper">
+                <span>{{ $t('channel_moderated_topic') }}</span>
+                <input v-model="modeT" type="checkbox">
+            </label>
+            <label class="u-checkbox-wrapper">
+                <span>{{ $t('channel_external') }}</span>
+                <input v-model="modeN" type="checkbox">
+            </label>
+            <label>
+                <span>{{ $t('password') }}</span>
+                <input v-model.lazy="modeK" type="text" class="u-input">
+            </label>
+        </form>
+    </div>
+</template>
+
+<script>
+'kiwi public';
+
+// Helper to generate Vues computed methods for simple channel modes.
+// Eg. +i, +n, etc
+function generateComputedMode(mode) {
+    return {
+        get: function computedModeGet() {
+            return this.modeVal(mode);
+        },
+        set: function computedModeSet(newVal) {
+            return this.setMode((newVal ? '+' : '-') + mode);
+        },
+    };
+}
+
+// Helper to generate Vues computed methods for channel modes with a parameter
+// Eg. "+k key"
+function generateComputedModeWithParam(mode) {
+    return {
+        get: function computedModeWithParamGet() {
+            let val = this.modeVal(mode);
+            return val === false ?
+                '' :
+                val;
+        },
+        set: function computedModeWithParamSet(newVal) {
+            if (newVal) {
+                this.setMode('+' + mode, newVal);
+            } else {
+                this.setMode('-' + mode, this.modeVal(mode));
+            }
+        },
+    };
+}
+
+export default {
+    props: ['buffer'],
+    data: function data() {
+        return {
+            showPrevTopics: false,
+        };
+    },
+    computed: {
+        modeM: generateComputedMode('m'),
+        modeI: generateComputedMode('i'),
+        modeS: generateComputedMode('s'),
+        modeT: generateComputedMode('t'),
+        modeN: generateComputedMode('n'),
+        modeK: generateComputedModeWithParam('k'),
+        topic: {
+            get: function computedTopicGet() {
+                return this.buffer.topic;
+            },
+            set: function computedTopicSet(newVal) {
+                let newTopic = newVal.replace('\n', ' ');
+                // TODO: Update irc-framework to insert a trailing : if the last argument is an
+                //       empty string. The trailing : makes a difference between things like
+                //       requesting a topic and changing to an empty topic
+                if (!newTopic.trim()) {
+                    this.buffer.getNetwork().ircClient.raw(`TOPIC ${this.buffer.name} :`);
+                } else {
+                    this.buffer.getNetwork().ircClient.setTopic(this.buffer.name, newTopic);
+                }
+            },
+        },
+        prevTopics() {
+            return this.buffer.topics.filter((topic) => topic.trim());
+        },
+    },
+    methods: {
+        updateBanList: function updateBanList() {
+            this.buffer.getNetwork().ircClient.raw('MODE', this.buffer.name, '+b');
+        },
+        setMode: function setMode(mode, param) {
+            this.buffer.getNetwork().ircClient.raw('MODE', this.buffer.name, mode, param);
+        },
+        modeVal: function modeVal(mode) {
+            let val = false;
+
+            if (typeof this.buffer.modes[mode] === 'undefined') {
+                // Specifically undefined = mode not set
+                val = false;
+            } else if (!this.buffer.modes[mode]) {
+                // Falsy value = mode set without value
+                val = true;
+            } else {
+                // Anything else = mode set with a value
+                val = this.buffer.modes[mode];
+            }
+
+            return val;
+        },
+        areWeAnOp: function areWeAnOp() {
+            return this.buffer.isUserAnOp(this.buffer.getNetwork().nick);
+        },
+    },
+};
+</script>
+
+<style>
+
+.kiwi-channelinfo-previoustopics {
+    margin: 0 10px 15px 10px;
+}
+
+.kiwi-channelinfo-previoustopics ul {
+    margin-top: 0;
+}
+
+</style>

package/apps/web/upstream/src/components/ChannelInvitelist.vue

@@ -0,0 +1,276 @@
+<template>
+    <div class="kiwi-invitelist">
+        <form class="u-form kiwi-invitelist" @submit.prevent="">
+            <a class="u-link" @click="updateInvitelist">{{ $t('invites_refresh') }}</a>
+
+            <div v-if="!channelIsInviteOnly" class="kiwi-invitelist-inviteonly-status">
+                {{ $t('invite_public_channel') }}
+                <a
+                    v-if="areWeAnOp"
+                    class="u-link"
+                    @click="setInviteOnly"
+                >{{ $t('invite_set_private') }}</a>
+            </div>
+            <div v-else class="kiwi-invitelist-inviteonly-status">
+                {{ $t('invite_private_channel') }}
+                <a
+                    v-if="areWeAnOp"
+                    class="u-link"
+                    @click="removeInviteOnly"
+                >{{ $t('invite_set_public') }}</a>
+            </div>
+
+            <span v-if="anyRegisteredUserCanJoin">{{ $t('invite_registered_only') }}</span>
+
+            <div>
+                <div v-if="supportsAccounts && areWeAnOp">
+                    <template v-if="knownAccounts.length > 0">
+                        <select ref="addInviteList">
+                            <option
+                                v-for="user in knownAccounts"
+                                :key="user.key" :value="user.account"
+                            >{{ user.account }}</option>
+                        </select>
+                        <button type="button" @click="addAccountInvite($refs.addInviteList.value)">
+                            {{ $t('invite_add_invite') }}
+                        </button>
+                    </template>
+                </div>
+                <div v-if="!supportsAccounts && areWeAnOp" class="kiwi-invitelist-addmask">
+                    <input ref="addInviteText" type="text" class="u-input">
+                    <button type="button" @click="addInvite($refs.addInviteText.value)">
+                        {{ $t('invite_add_invite') }}
+                    </button>
+                </div>
+
+                <table v-if="inviteList.length > 0" class="kiwi-invitelist-table">
+                    <tr>
+                        <th>{{ $t('invites_user') }}</th>
+                        <th>{{ $t('invites_by') }}</th>
+                        <th />
+                        <th />
+                    </tr>
+                    <tr v-for="invite in inviteListAccounts" :key="invite.invited">
+                        <td class="kiwi-invitelist-table-mask">
+                            {{ displayMask(invite) }}
+                        </td>
+                        <td class="kiwi-invitelist-table-invitedby">
+                            {{ invite.invited_by }}
+                        </td>
+                        <td class="kiwi-invitelist-table-invitedat">
+                            {{ (new Date(invite.invited_at * 1000)).toDateString() }}
+                        </td>
+                        <td class="kiwi-invitelist-table-actions">
+                            <i
+                                v-if="areWeAnOp"
+                                class="fa fa-trash"
+                                aria-hidden="true"
+                                @click="removeInvite(invite.invited)"
+                            />
+                        </td>
+                    </tr>
+                    <tr v-for="invite in inviteListNonAccounts" :key="invite.invited">
+                        <td class="kiwi-invitelist-table-mask">
+                            {{ displayMask(invite) }}
+                        </td>
+                        <td class="kiwi-invitelist-table-invitedby">
+                            {{ invite.invited_by }}
+                        </td>
+                        <td class="kiwi-invitelist-table-invitedat">
+                            {{ (new Date(invite.invited_at * 1000)).toDateString() }}
+                        </td>
+                        <td class="kiwi-invitelist-table-actions">
+                            <i
+                                v-if="areWeAnOp"
+                                class="fa fa-trash"
+                                aria-hidden="true"
+                                @click="removeInvite(invite.invited)"
+                            />
+                        </td>
+                    </tr>
+                </table>
+            </div>
+
+            <div v-if="is_refreshing">
+                {{ $t('invites_refreshing') }}
+            </div>
+        </form>
+    </div>
+</template>
+<script>
+
+import _ from 'lodash';
+import * as IrcdDiffs from '@/helpers/IrcdDiffs';
+
+function inviteListSorter(a, b) {
+    let aMask = a.invited.toUpperCase();
+    let bMask = b.invited.toUpperCase();
+
+    if (aMask < bMask) {
+        return -1;
+    }
+    if (aMask > bMask) {
+        return 1;
+    }
+
+    return 0;
+}
+
+export default {
+    props: ['buffer'],
+    data() {
+        return {
+            inviteList: [],
+            is_refreshing: false,
+        };
+    },
+    computed: {
+        supportsAccounts() {
+            return !!this.extban;
+        },
+        extban() {
+            return IrcdDiffs.extbanAccount(this.buffer.getNetwork());
+        },
+        inviteListAccounts() {
+            let accounts = this.inviteList.filter((i) => i.invited.indexOf(this.extban) === 0);
+            accounts.sort(inviteListSorter);
+            return accounts;
+        },
+        inviteListNonAccounts() {
+            let invites = [];
+
+            // If the ircd doesn't support accounts extban type, consider every invex non-account
+            if (!this.supportsAccounts) {
+                invites = this.inviteList;
+            } else {
+                invites = this.inviteList.filter((i) => i.invited.indexOf(this.extban) !== 0);
+            }
+
+            invites.sort(inviteListSorter);
+            return invites;
+        },
+        channelIsInviteOnly() {
+            return typeof this.buffer.modes.i !== 'undefined';
+        },
+        anyRegisteredUserCanJoin() {
+            if (!this.supportsAccounts) {
+                return false;
+            }
+
+            if (!this.channelIsInviteOnly) {
+                return false;
+            }
+
+            let extban = this.extban;
+            // Find any invite that only consists of the extban and nothing else. Eg. '~a:'
+            return !!this.inviteListAccounts.find((invite) => invite.invited === extban + ':');
+        },
+        areWeAnOp() {
+            return this.buffer.isUserAnOp(this.buffer.getNetwork().nick);
+        },
+        knownAccounts() {
+            // Get an array of every account name we're aware of on the network, excluding
+            // the ones we already have in our invite list
+            let users = this.buffer.getNetwork().users;
+            let extban = this.extban;
+            let inviteAccountNames = this.inviteListAccounts.map((i) => {
+                let mask = i.invited;
+                return mask.replace(extban + ':', '');
+            });
+
+            let accountUsers = [];
+            Object.values(users).forEach((user) => {
+                if (user.account && inviteAccountNames.indexOf(user.account) === -1) {
+                    accountUsers.push(user);
+                }
+            });
+
+            return _.orderBy(accountUsers, ['account', 'nick']);
+        },
+    },
+    created() {
+        this.updateInvitelist();
+    },
+    methods: {
+        displayMask(invite) {
+            let display = invite.invited.replace(this.extban + ':', '');
+            display = display || this.$t('invite_any_registered');
+            return display;
+        },
+        updateInvitelist() {
+            if (this.buffer.getNetwork().state !== 'connected' || this.is_refreshing) {
+                return;
+            }
+            let channelName = this.buffer.name;
+            this.is_refreshing = true;
+            this.buffer.getNetwork().ircClient.inviteList(channelName, (inviteEvent) => {
+                if (inviteEvent) {
+                    this.inviteList = inviteEvent.invites;
+                } else {
+                    this.inviteList = [];
+                }
+
+                this.is_refreshing = false;
+            });
+        },
+        removeInvite(mask) {
+            let channelName = this.buffer.name;
+            this.buffer.getNetwork().ircClient.removeInvite(channelName, mask);
+            this.inviteList = this.inviteList.filter((invite) => invite.invited !== mask);
+        },
+        addAccountInvite(accountName) {
+            if (!accountName) {
+                return;
+            }
+
+            let network = this.buffer.getNetwork();
+            network.ircClient.addInvite(this.buffer.name, `${this.extban}:${accountName}`);
+            this.updateInvitelist();
+        },
+        addInvite(mask) {
+            let network = this.buffer.getNetwork();
+            network.ircClient.addInvite(this.buffer.name, mask);
+            this.updateInvitelist();
+        },
+        setInviteOnly() {
+            this.buffer.getNetwork().ircClient.mode(this.buffer.name, '+i');
+        },
+        removeInviteOnly() {
+            this.buffer.getNetwork().ircClient.mode(this.buffer.name, '-i');
+        },
+    },
+};
+</script>
+<style lang="less">
+.kiwi-invitelist-inviteonly-status {
+    margin-top: 10px;
+}
+
+.kiwi-invitelist-table {
+    width: 100%;
+    border-collapse: collapse;
+    line-height: 20px;
+    margin-top: 10px;
+}
+
+.kiwi-invitelist-table-invitedat {
+    min-width: 150px;
+}
+
+.kiwi-invitelist-table-actions {
+    min-width: 50px;
+    text-align: center;
+    cursor: pointer;
+    position: relative;
+    transition: all 0.3s;
+    z-index: 1;
+}
+
+.kiwi-invitelist-addmask {
+    display: flex;
+}
+
+.kiwi-invitelist-addmask > button {
+    flex-shrink: 0;
+}
+</style>