Teams Invite Improvements (Creation, Expiry)

frontend/src/components/routes/Team.vue

@@ -20,6 +20,26 @@
 </style>
 <template>
   <main>
+    <modal-window v-model='inviteModal' @click.stop='() => {}'>
+      <div slot="header">
+        <p>Invite people to {{user.name}}</p>
+      </div>
+      <div slot='main' class="modal-card-body">
+        <b-field label="Amount of uses (0 is Unlimited)">
+          <b-input :value="invite.maxUses" v-model="invite.maxUses">
+          </b-input>
+        </b-field>
+        <b-button @click="generateInvite()">Refresh</b-button>
+        <b-field label="Invite URL">
+          <b-input
+            :value="'https://kaverti.com/invite/' + invite.code"
+            placeholder="Loading"
+            disabled="disabled">
+          </b-input>
+        </b-field>
+      </div>
+      <button slot='footer' class='button button--modal' @click.stop='setShareModalState(false)'>OK</button>
+    </modal-window>
     <section v-if="!$store.state.experimentsStore.teams" class="hero is-info is-large">
       <div class="hero-body">
         <div class="container">
@@ -81,6 +101,10 @@
           <b-button v-if="$store.state.username && $store.state.UserId !== user.OwnerId && joined" class="button is-danger" style="float: right" @click='leaveTeam()'>
             Leave Team
           </b-button>
+          <br><br>
+          <b-button v-if="joined" style="float: right" @click="generateInvite()">
+            Invite
+          </b-button>
         </div>
       </div>
     </div>
@@ -111,12 +135,13 @@
 
 <script>
 import MenuButton from '../MenuButton'
+import ModalWindow from "@/components/ModalWindow";
 import AjaxErrorHandler from "@/assets/js/errorHandler";
 
 export default {
   name: 'Team',
   // eslint-disable-next-line vue/no-unused-components
-  components: {MenuButton},
+  components: {MenuButton, ModalWindow},
   data () {
     return {
       menuItems: [
@@ -131,6 +156,11 @@ export default {
       user: null,
       relationship: false,
       joined: false,
+      inviteModal: false,
+      invite: {
+        code: '',
+        maxUses: 0
+      },
       relationships: {
         type: ''
       }
@@ -199,6 +229,18 @@ export default {
             })
         })
     },
+    generateInvite () {
+      this.axios
+        .put(process.env.VUE_APP_APIENDPOINT + process.env.VUE_APP_APIVERSION + '/' + 'teams/admin/' + this.user.username + '/invites/create', {
+          maxUses: this.invite.maxUses
+        })
+        .then(res => {
+          this.invite.code = res.data.code
+          this.inviteModal = true
+        }).catch(e => {
+          AjaxErrorHandler(this.$store)(e)
+        })
+    },
     joinTeam () {
       this.axios
         .put(process.env.VUE_APP_APIENDPOINT + process.env.VUE_APP_APIVERSION + '/' + 'teams/join/' + this.user.username)

frontend/src/components/routes/TeamInvites.vue

@@ -0,0 +1,292 @@
+<style>
+.team-img {
+  border-radius: 50%;
+}
+.vertical-alt {
+  margin: 0;
+  position: absolute;
+  top: 50%;
+  left: 50%;
+  -ms-transform: translate(-50%, -50%);
+  transform: translate(-50%, -50%);
+}
+.limit{
+  margin-top: 0.5rem;
+  word-break: break-all;
+}
+</style>
+<template>
+  <main>
+    <modal-window v-model='inviteModal' @click.stop='() => {}'>
+      <div slot="header">
+        <p>Invite people to {{$route.params.username}}</p>
+      </div>
+      <div slot='main' class="modal-card-body">
+        <b-field label="Amount of uses (0 is Unlimited)">
+          <b-input :value="invite.maxUses" v-model="invite.maxUses">
+          </b-input>
+        </b-field>
+        Please select a role for the user to be auto assigned (optional)
+        <div class="field">
+          <br>
+          <b-radio v-model="invite.RoleId"
+                   v-for="role in roles"
+                   :key="role.id"
+                   :value="role.id"
+                   :native-value="role.id"
+                   type="is-info">
+            {{role.name}}
+          </b-radio>
+        </div>
+        <b-button @click="generateInvite()">Refresh</b-button>
+        <b-field label="Invite URL">
+          <b-input
+            :value="'https://kaverti.com/invite/' + invite.code"
+            placeholder="Loading"
+            disabled="disabled">
+          </b-input>
+        </b-field>
+      </div>
+      <button slot='footer' class='button button--modal' @click.stop='setShareModalState(false)'>OK</button>
+    </modal-window>
+    <div class="section column">
+      <div class="box">
+        <h1>Invites</h1>
+        <b-button class="button field is-danger" @click="invalidate()"
+                :disabled="!selected">
+          Delete selected
+        </b-button>
+        &nbsp;
+        <b-button class="field is-info" @click="generateInvite()">
+          Generate invite
+        </b-button>
+        <b-table
+          :data="users"
+          :paginated="isPaginated"
+          :per-page="perPage"
+          :current-page.sync="currentPage"
+          :pagination-simple="isPaginationSimple"
+          :pagination-position="paginationPosition"
+          :default-sort-direction="defaultSortDirection"
+          :pagination-rounded="isPaginationRounded"
+          :sort-icon="sortIcon"
+          :opened-detailed="defaultOpenedDetails"
+          :sort-icon-size="sortIconSize"
+          :selected.sync="selected"
+          focusable
+          default-sort="user.id"
+          aria-next-label="Next page"
+          aria-previous-label="Previous page"
+          aria-page-label="Page"
+          aria-current-label="Current page">
+
+          <b-table-column field="user.code" label="Code" sortable v-slot="props">
+            {{ props.row.code }}
+          </b-table-column>
+
+
+          <b-table-column field="user.uses" label="Uses" sortable v-slot="props">
+            {{ props.row.uses }}
+          </b-table-column>
+
+          <b-table-column field="user.maxUses" label="Max Uses" sortable v-slot="props">
+            {{ props.row.maxUses }}
+          </b-table-column>
+
+          <b-table-column field="user.User.username" label="Created by" sortable v-slot="props">
+            {{ props.row.User.username }}
+          </b-table-column>
+
+          <b-table-column field="date" label="Date" sortable centered v-slot="props">
+                <span class="tag is-success">
+                    {{ new Date(props.row.createdAt).toLocaleDateString() }}
+                </span>
+          </b-table-column>
+        </b-table>
+      </div>
+    </div>
+    <p name='fade' mode='out-in'>
+    <center><loading-message key='loading' v-if='loading'></loading-message></center>
+    <center><div class='overlay_message' v-if='!loading && !users.length'>
+      Something went wrong while loading the Transaction Log, check your internet connection, or check the <a href="https://status.troplo.com">Service Status</a>
+    </div></center></p>
+  </main>
+</template>
+<script>
+import LoadingMessage from '../LoadingMessage';
+import ModalWindow from "@/components/ModalWindow";
+import throttle from 'lodash.throttle';
+import AjaxErrorHandler from '../../assets/js/errorHandler';
+
+export default {
+  name: 'Transactions',
+  components: {
+    LoadingMessage,
+    ModalWindow
+  },
+  data () {
+    return {
+      search: '',
+      users: [],
+      roles: [],
+      isPaginated: true,
+      isPaginationSimple: false,
+      isPaginationRounded: false,
+      paginationPosition: 'bottom',
+      defaultSortDirection: 'asc',
+      sortIcon: 'arrow-up',
+      sortIconSize: 'is-small',
+      currentPage: 1,
+      perPage: 15,
+      deleteCode: '',
+      defaultOpenedDetails: [1],
+      showDetailIcon: true,
+      selected: null,
+      invite: {
+        maxUses: 0,
+        RoleId: 0,
+        code: ''
+      },
+      loading: true,
+      offset: 0,
+      limit: 15,
+      showTeamTab: 0,
+      inviteModal: false,
+      tcreateProd: {
+        username: '',
+        name: '',
+
+        loading: false,
+
+        errors: {
+          username: '',
+          name: ''
+        }
+      },
+
+      roleOptions: [
+        { name: 'Admins', value: 'admin' },
+        { name: 'Users', value: 'user' }
+      ],
+      roleSelected: ['admin', 'user'],
+
+      tableSort: {
+        column: 'username',
+        sort: 'desc'
+      }
+    }
+  },
+  methods: {
+    invalidate() {
+      this.axios
+        .delete(process.env.VUE_APP_APIENDPOINT + process.env.VUE_APP_APIVERSION + '/' + 'teams/admin/' + this.$route.params.username + '/invites/delete/' + this.selected.code)
+        .then(()=> {
+          this.resetFetchData()
+          this.selected = null
+        })
+        .catch((e) => {
+          AjaxErrorHandler(this.$store)(e)
+        })
+    },
+    generateInvite () {
+      this.axios
+        .put(process.env.VUE_APP_APIENDPOINT + process.env.VUE_APP_APIVERSION + '/' + 'teams/admin/' + this.$route.params.username + '/invites/create', {
+          maxUses: this.invite.maxUses,
+          RoleId: this.invite.RoleId
+        })
+        .then(res => {
+          this.invite.code = res.data.code
+          this.inviteModal = true
+        }).catch(e => {
+        AjaxErrorHandler(this.$store)(e)
+      })
+    },
+    fetchData () {
+      if(this.offset === null) return;
+
+      let url = process.env.VUE_APP_APIENDPOINT + process.env.VUE_APP_APIVERSION + `/` + `teams/admin/${this.$route.params.username}/invites/list?
+					sort=${this.tableSort.column}
+					&order=${this.tableSort.sort}
+					&offset=${this.offset}
+				`;
+      if(this.roleSelected.length === 1) {
+        url += '&role=' + this.roleSelected[0];
+      }
+      if(this.search.length) {
+        url += '&search=' + encodeURIComponent(this.search.trim());
+      }
+
+      this.loading = true;
+      this.axios
+        .get(url)
+        .then(res => {
+          this.users.push(...res.data);
+          this.loading = /*loading =*/ false;
+
+          //If returned data is less than the limit
+          //then there must be no more pages to paginate
+          if(res.data.length < this.limit) {
+            this.offset = null;
+          } else {
+            this.offset+= this.limit;
+          }
+        })
+        .catch(e => {
+          AjaxErrorHandler(this.$store)(e);
+          this.loading = /*loading =*/ false;
+        });
+      this.axios
+        .get( process.env.VUE_APP_APIENDPOINT + process.env.VUE_APP_APIVERSION + '/' + 'teams/view/' + this.$route.params.username + "/roles")
+        .then(res => {
+          this.roles.push(...res.data);
+          this.loading = /*loading =*/ false;
+
+          //If returned data is less than the limit
+          //then there must be no more pages to paginate
+          if(res.data.length < this.limit) {
+            this.offset = null;
+          } else {
+            this.offset+= this.limit;
+          }
+        })
+        .catch(e => {
+          AjaxErrorHandler(this.$store)(e);
+          this.loading = /*loading =*/ false;
+        });
+    },
+    resetFetchData () {
+      this.offset = 0;
+      this.users = [];
+      this.roles = [];
+
+      this.fetchData();
+    }
+  },
+  getNewerUsers () {
+    this.loadingNewer = true
+
+    this.axios
+      .get(process.env.VUE_APP_APIENDPOINT + process.env.VUE_APP_APIVERSION + '/' + 'transactions' + '?limit=' + this.newUsers)
+      .then(res => {
+        this.loadingNewer = false
+        this.newUsers = 0
+
+        this.threads.unshift(...res.data.Threads)
+      })
+      .catch((e) => {
+        this.loadingNewer = false
+        AjaxErrorHandler(this.$store)(e)
+      })
+  },
+  mounted () {
+    this.fetchData();
+  },
+  watch: {
+    tableSort: 'resetFetchData',
+    roleSelected: 'resetFetchData',
+    search: throttle(function () {
+      this.resetFetchData();
+    }, 200)
+  }
+}
+</script>

frontend/src/components/routes/TeamRequests.vue

@@ -1,5 +1,5 @@
 <template>
   <main>
-
+    <h1>Replaced with Team Invites</h1>
   </main>
 </template>

frontend/src/components/routes/TeamSettings.vue

@@ -42,6 +42,7 @@
           { name: 'Users', route: 'users', icon: 'users'},
           { name: 'Join Requests', route: 'requests', icon: 'envelope'},
           { name: 'Team Privacy', route: 'privacy', icon: 'lock'},
+          { name: 'Invites', route: 'invites', icon: 'envelope'},
         ],
         selected: 0,
         team: null

frontend/src/main.js

@@ -80,6 +80,7 @@ const TeamUsers = () => import('./components/routes/TeamUsers')
 const TeamWall = () => import('./components/routes/TeamWall')
 const TeamMembers = () => import('./components/routes/TeamMembers')
 const TeamInvite = () => import('./components/routes/TeamInvite')
+const TeamInvites = () => import('./components/routes/TeamInvites')
 
 const User = () => import('./components/routes/User')
 const UserPosts = () => import('./components/routes/UserPosts')
@@ -207,6 +208,7 @@ const router = new VueRouter({
         { path: 'roles', component: TeamRoles },
         { path: 'privacy', component: TeamPrivacy },
         { path: 'requests', component: TeamRequests },
+        { path: 'invites', component: TeamInvites }
       ] },
     { path: '/t/:username', component: Team, children: [
         { path: 'items', component: UserMarketplace },

models/bannedUsernames.js

@@ -7,12 +7,10 @@ module.exports = (sequelize, DataTypes) =>{
             type: DataTypes.STRING,
             allowNull: false
         },
-        createdAt: sequelize.DATE,
-        UpdatedAt: sequelize.DATE,
+        createdAt: DataTypes.DATE,
+        UpdatedAt: DataTypes.DATE,
     }, {
         // Other model options go here
     });
     return bannedUsernames;
-}
-
-
+}

models/team_invite.js

@@ -7,7 +7,6 @@ var escaped_str = require('querystring')
 const Errors = require('../lib/errors')
 let pagination = require('../lib/pagination.js')
 let crypto = require("crypto");
-let inviteCode = crypto.randomBytes(20).toString('hex');
 
 module.exports = (sequelize, DataTypes) => {
     let TeamInvite = sequelize.define('TeamInvite', {
@@ -15,16 +14,8 @@ module.exports = (sequelize, DataTypes) => {
             type: DataTypes.BIGINT,
             allowNull: false
         },
-        createdAt: {
-            type: DataTypes.DATE
-        },
-        updatedAt: {
-            type: DataTypes.DATE
-        },
         code: {
             type: DataTypes.TEXT,
-            default: inviteCode,
-            defaultValue: inviteCode,
             unique: true
         },
         maxUses: {
@@ -44,7 +35,10 @@ module.exports = (sequelize, DataTypes) => {
             defaultValue: 0
         },
         RoleId: {
-            type: DataTypes.BIGINT
+            type: DataTypes.BIGINT,
+            allowNull: true,
+            defaultValue: 0,
+            default: 0
         }
     }, {
         classMethods: {
@@ -62,7 +56,7 @@ module.exports = (sequelize, DataTypes) => {
             }
         },
         instanceMethods: {
-            async killInvite() {
+            async killInvite(invite) {
                 await this.destroy()
             },
             async createInvite(team) {

routes/team.js

@@ -497,21 +497,30 @@ router.put('/leave/:username', auth, async(req, res, next) => {
         }
     } catch (e) { next(e) }
 })
-router.get('/invite/:username', auth, async(req, res, next) => {
+router.get('/invite/:username', async(req, res, next) => {
     try {
-        await Ban.ReadOnlyMode(req.userData.username)
         let code = await TeamInvite.findOne({
             where: {code: req.params.username},
             include: {model: Team, attributes: { exclude: [ 'banReason' ]}}
         })
         if (code) {
-            res.status(200)
-            res.json(code.toJSON())
+            if(code.maxUses === 0) {
+                res.status(200)
+                res.json(code.toJSON())
+            } else if(code.uses >= code.maxUses) {
+                throw Errors.invalidInvite
+            } else if(code.uses < code.maxUses) {
+                res.status(200)
+                res.json(code.toJSON())
+            } else {
+                throw Errors.invalidInvite
+            }
         } else {
             throw Errors.invalidInvite
         }
     } catch (e) { next(e) }
 })
+
 router.post('/invite/:code', auth, async(req, res, next) => {
     try {
         await Ban.ReadOnlyMode(req.userData.username)
@@ -532,24 +541,89 @@ router.post('/invite/:code', auth, async(req, res, next) => {
             if (teamJoinTest) {
                 throw Errors.joinedTeam
             }
-            let role = await TeamRoles.findOne({
-                where: {teamId: team.id, name: "Members"}
-            })
-            let join = {
-                userId: req.userData.UserId,
-                teamId: team.id,
-                roles: {"deprecated": "deprecated"}
+            if(code.maxUses >= code.uses) {
+                throw Errors.inviteInvalid
+            } else if(code.maxUses === 0) {
+                let role = await TeamRoles.findOne({
+                    where: {teamId: team.id, name: "Members"}
+                })
+                if(code.RoleId >= 0) {
+                    let roleLookup = await TeamInvite.findOne({
+                        where: {code: req.body.RoleId, TeamId: team.id}
+                    })
+                    if(roleLookup) {
+                        let join = {
+                            userId: req.userData.UserId,
+                            teamId: team.id,
+                            roles: {"deprecated": "deprecated"}
+                        }
+                        console.log(role)
+                        let roleUser = {
+                            UserId: req.userData.UserId,
+                            TeamId: team.id,
+                            RoleId: role.id,
+                            Role2Id: roleLookup.id
+                        }
+                        await TeamMembers.create(join)
+                        await TeamMemberRole.create(roleUser)
+                        res.status(200)
+                        res.json({success: true})
+                    } else {
+                        let join = {
+                            userId: req.userData.UserId,
+                            teamId: team.id,
+                            roles: {"deprecated": "deprecated"}
+                        }
+                        console.log(role)
+                        let roleUser = {
+                            UserId: req.userData.UserId,
+                            TeamId: team.id,
+                            RoleId: role.id
+                        }
+                        await TeamMembers.create(join)
+                        await TeamMemberRole.create(roleUser)
+                        res.status(200)
+                        res.json({success: true})
+                    }
+                } else {
+                    let join = {
+                        userId: req.userData.UserId,
+                        teamId: team.id,
+                        roles: {"deprecated": "deprecated"}
+                    }
+                    console.log(role)
+                    let roleUser = {
+                        UserId: req.userData.UserId,
+                        TeamId: team.id,
+                        RoleId: role.id
+                    }
+                    await TeamMembers.create(join)
+                    await TeamMemberRole.create(roleUser)
+                    res.status(200)
+                    res.json({success: true})
+                }
+            } else if(code.uses < code.maxUses) {
+                let role = await TeamRoles.findOne({
+                    where: {teamId: team.id, name: "Members"}
+                })
+                let join = {
+                    userId: req.userData.UserId,
+                    teamId: team.id,
+                    roles: {"deprecated": "deprecated"}
+                }
+                console.log(role)
+                let roleUser = {
+                    UserId: req.userData.UserId,
+                    TeamId: team.id,
+                    RoleId: role.id,
+                }
+                await TeamMembers.create(join)
+                await TeamMemberRole.create(roleUser)
+                res.status(200)
+                res.json({success: true})
+            } else {
+                throw Errors.inviteInvalid
             }
-            console.log(role)
-            let roleUser = {
-                UserId: req.userData.UserId,
-                TeamId: team.id,
-                RoleId: role.id,
-            }
-            await TeamMembers.create(join)
-            await TeamMemberRole.create(roleUser)
-            res.status(200)
-            res.json({success: true})
         } else {
             throw Errors.inviteInvalid
         }

routes/team_admin.js

@@ -257,7 +257,8 @@ try {
             maxUses: req.body.maxUses,
             RoleId: req.body.RoleId,
             TeamId: team.id,
-            UserId: req.userData.UserId
+            UserId: req.userData.UserId,
+            code: crypto.randomBytes(20).toString('hex')
         })
         let createJSON = create.toJSON()
         res.status(200)
@@ -268,4 +269,46 @@ try {
 } catch (e) { next(e) }
 })
 
+router.get('/:username/invites/list', auth, async(req, res, next) => {
+    try {
+        let team = await Team.findOne({
+            where: {username: req.params.username}
+        });
+        if(team) {
+            let roles = await TeamInvite.findAll({
+                where: {
+                    TeamId: team.id
+                },
+                include: { model: User, attributes: ['username', 'createdAt', 'id', 'color', 'picture', 'locked', 'admin', 'booster', 'executive', 'bot'] },
+            })
+            res.status(200)
+            res.json(roles)
+        } else {
+            throw Errors.teamDoesNotExist
+        }
+    } catch (e) { next(e) }
+})
+
+router.delete('/:username/invites/delete/:code', auth, async(req, res, next) => {
+    try {
+        let team = await Team.findOne({
+            where: {username: req.params.username}
+        });
+        if(team) {
+            let code = await TeamInvite.findOne({
+                where: {code: req.params.code, TeamId: team.id}
+            });
+            if(code) {
+                await code.killInvite(req.params.code)
+                res.status(200)
+                res.json({success: true})
+            } else {
+                throw Errors.inviteInvalid
+            }
+        } else {
+            throw Errors.teamDoesNotExist
+        }
+    } catch (e) { next(e) }
+})
+
 module.exports = router;