visual polish and bugfixes. auto-refreshing

package-lock.json

       }
     },
     "rpclibrary": {
-      "version": "1.7.0",
-      "resolved": "https://registry.npmjs.org/rpclibrary/-/rpclibrary-1.7.0.tgz",
-      "integrity": "sha512-HIL5YzFF53fACOWvI403hJZnGYoXLJGrGc0n1HYZH6rnnfEaBcogemZrCbyoOvnG204LH882e8VdpB+WBTEY/g==",
+      "version": "1.7.1",
+      "resolved": "https://registry.npmjs.org/rpclibrary/-/rpclibrary-1.7.1.tgz",
+      "integrity": "sha512-Ibo3qfURnQgZAq0eA2o+L9+PWaloJ4PHZs4ak42LL9fRgdWZXn33HAtowV0K2HVckbvrBvFqj/+PWTrWWBSOeg==",
       "requires": {
         "bsock": "^0.1.9",
         "http": "0.0.0",

package.json

   "scripts": {
     "tsc": "tsc",
     "launch": "node lib/src/backend/Launcher.js",
-    "start": "npm run build; npm run launch",
-    "start-backend": "npm run build-backend; node lib/src/backend/Launcher.js",
-    "build": "npm run build-backend; npm run build-frontend",
-    "test": "npm run clean && npm run build-backend && mocha lib/test/backendTest.js",
-    "build-backend": "tsc;",
-    "build-frontend": "mkdir dist; mkdir dist/static; npm run build-dashboard;",
-    "build-dashboard": "cd src/frontend; npm i && npm run build; cp -r dist/* ../../dist/static",
-    "clean": "rm -rf lib plugins conf widget .rpt2_cache *.js *.ts src/frontend/dist data",
-    "update-frontblock": "npm remove frontblock frontblock-generic; npm install frontblock-generic@latest frontblock@latest",
+    "start": "npm run build && npm run launch",
+    "start-backend": "npm run build-backend && npm run launch",
+    "test": "npm run backend && npm run build-backend && mocha lib/test/backendTest.js",
+    "build": "npm run build-backend && npm run build-frontend",
+    "build-backend": "npm run clean-backend && tsc",
+    "build-frontend": "npm run clean-frontend && (mkdir static || rm -rf static/*) && npm run build-dashboard",
+    "build-dashboard": "cd src/frontend && npm i && npm run build && cp -r dist/* ../../static",
+    "clean": "rm -rf data && npm run clean-backend && npm run clean-frontend",
+    "clean-backend": "rm -rf lib plugins config widget .rpt2_cache *.js *.ts",
+    "clean-frontend": "rm -rf src/frontend/dist static",
     "webpack": "webpack --config src/backend/webpack.prod.js --progress --colors"
   },
   "repository": {
     "path": "^0.12.7",
     "reflect-metadata": "^0.1.13",
     "rimraf": "^3.0.0",
-    "rpclibrary": "^1.7.0",
+    "rpclibrary": "^1.7.1",
     "simple-git": "^1.124.0",
     "spawn-sync": "^2.0.0",
     "sqlite3": "^4.1.1",

src/backend/Admin/Admin.ts

 import { IAdmin } from './Interface';
 import { Injector } from '../Injector/Injector';
 import { Shoutbox } from '../Components/Shoutbox/Shoutbox';
+import { PubSub } from '../Components/PubSub/PubSub';
 
 
 const logger = getLogger("admin", 'debug') 
         RaidManager,
         CharacterManager,
         UserManager,
-        Shoutbox
+        Shoutbox,
+        PubSub
     ]
 })
 export class FrontworkAdmin 
                     dbConf: {
                         client: 'sqlite3',
                         connection: {
-                            filename: Path.join(__dirname, "data/frontworkAdmin.sqlite")
+                            filename: Path.resolve(__dirname, '../../../..', "data/frontworkAdmin.sqlite")
                         },
                         useNullAsDefault: true,
                     }
     getTableDefinitions(): TableDefiniton[]{
         return [
             ...this.frontworkComponents
-        ].flatMap(exporter => exporter.getTableDefinitions())
+        ]
+        .filter(exp => exp.getTableDefinitions != null)
+        .flatMap(exp => exp.getTableDefinitions())
     }
 
     private startWebsocket(){
         
         let port:number = this.config.getConfig().httpPort
         this.express = express()
-        this.express.use('/', express.static('dist/static'))
+        this.express.use('/', express.static('static'))
 
         /**
          * get the compiled FrontendPlugins.js

src/backend/Components/Item/ItemManager.ts

-import { T1, T2, allItems, _Tiers, Tiers } from "../../Types/Items";
+import { allItems, _Tiers, Tiers } from "../../Types/Items";
 import { Inject, Injectable } from "../../Injector/ServiceDecorator";
 import { ItemManagerFeatureIfc, ItemManagerIfc } from "./RPCInterface";
 import { FrontworkComponent } from "../../Types/FrontworkComponent";
 import { TableDefinitionExporter } from "../../Types/Interfaces";
-import { TableDefiniton, Item, User, Character, SRToken, SRPriority, Spec, Signup } from "../../Types/Types";
+import { TableDefiniton, Item, User, Character, SRToken, SRPriority, Spec, Signup, Raid } from "../../Types/Types";
 import { IAdmin } from "../../Admin/Interface";
 import { IItemManager } from "./Interface";
 import { getLogger } from "log4js";
 import { IUserManager } from "../User/Interface";
 import { ICharacterManager } from "../Character/Interface";
+import { IPubSub } from "../PubSub/Interface";
+import { IRaidManager } from "../Raid/Interface";
 
 const fetch = require('node-fetch')
 const xml2js = require('xml2js');
     @Inject(ICharacterManager)
     private character: ICharacterManager
 
+    @Inject(IPubSub)
+    private pubsub: IPubSub<any>
+
+    @Inject(IRaidManager)
+    private raidManager: IRaidManager
+
     exportRPCs = () => [
         this.getItems,
         this.getItem,
         ]
     }]
 
+    notifyRaid = async (raid:Raid | {id:number}) => {
+        const data = await this.raidManager.getRaidData(<Raid>raid)
+        this.pubsub.publish(""+raid.id, data)
+        await this.notifyRaids()
+    }
+
+    notifyRaids = async () => {
+        this.pubsub.publish('raids', undefined)
+    }
+
     wipeCurrencyAndItems = async () => {
         await Promise.all([
             this.userManager.wipeCurrency(),
 
         await this.userManager.decrementCurrency(record.user, item.tier, 1)
         const modifier = await this.calculatePriorities(itemname, character)
-
+        
         const tx = await this.admin.knex.transaction()
 
         if(streaks.length > 0){
             const myStreak = streaks.find(token => token.itemname === itemname)
             if(myStreak){
-
                 //getLogger('ItemManager').debug('update signupid and increment level')
                 await this.admin
                 .knex(item.tier+'tokens')
 
             if(myStreak){
                 await tx.commit()
+                await this.notifyRaid({id: signup.raidid})
+
                 return await this.getToken(character, item)
             }
         }
             })
         }
         await tx.commit()
+        await this.notifyRaid({id: signup.raidid})
+
         return await this.getToken(character, item)
     }
 

src/backend/Components/PubSub/Interface.ts

+import { SubscriptionResponse } from "rpclibrary"
+
+export class IPubSub<UpdateType>{
+    publish: (topic: string, p: UpdateType) => void
+    subscribe: (topic:string, callback: (p:UpdateType)=>any) => Promise<SubscriptionResponse>
+    unsubscribe: (uuid: string) => Promise<void>
+}

src/backend/Components/PubSub/PubSub.ts

+import { Injectable } from "../../Injector/ServiceDecorator";
+import { SubscriptionResponse, makeSubResponse, RPCExporter } from "rpclibrary";
+import { IPubSub } from "./Interface";
+
+@Injectable(IPubSub)
+export class PubSub<UpdateType = any>
+implements RPCExporter{
+    name = "PubSub"
+    subs : {
+        [topic in string]: {
+            [uuid in string]: (p:UpdateType)=>any
+        }
+    }= {}
+
+    exportRPCs = () => [
+        this.unsubscribe,
+        {
+            name: 'subscribe',
+            hook: this.subscribe,
+            onClose: (subres, rpcName) => {
+                this.unsubscribe(subres.uuid)
+            }
+        }
+    ]
+
+    publish = ( topic: string, msg: UpdateType ) => {
+        if(!this.subs[topic]) this.subs[topic] = {}
+        Object.entries(this.subs[topic]).forEach(([uuid, callback]:[string, Function]) => {
+            try{
+                callback(msg)
+            }catch(e){
+                delete this.subs[topic][uuid]
+            }
+        })
+    }
+
+    subscribe = async (topic:string, callback:(p:UpdateType)=>any) : Promise<SubscriptionResponse<{topic: string}>> => {
+        const resp = makeSubResponse({
+            topic: topic
+        })
+        if(!this.subs[topic]) this.subs[topic] = {}
+        this.subs[topic][resp.uuid] = callback
+        return resp
+    }
+
+    private unsubscribe = async (uuid: string) => {
+        Object.entries(this.subs).forEach(([topic, submap]) => {           
+            delete submap[uuid]
+            if(Object.keys(submap).length === 0)
+                delete this.subs[topic]
+        })
+    }
+}

src/backend/Components/PubSub/RPCInterface.ts

+import { IPubSub } from "./Interface";
+
+export type PubSubIfc<UpdateType = any> = {
+    PubSub:{
+        subscribe: IPubSub<UpdateType>['subscribe']
+        unsubscribe: IPubSub<UpdateType>['unsubscribe']
+    }
+}

src/backend/Components/Raid/RaidManager.ts

 import { _Tiers } from "../../Types/Items";
 import { IItemManager } from "../Item/Interface";
 import { ItemManager } from "../Item/ItemManager";
+import { IPubSub } from "../PubSub/Interface";
 
 @Injectable(IRaidManager)
 export class RaidManager
-implements FrontworkComponent<RaidManagerIfc, RaidManagerFeatureIfc>, IRaidManager{
-    name = "RaidManager" as "RaidManager";    
+    implements FrontworkComponent<RaidManagerIfc, RaidManagerFeatureIfc>, IRaidManager {
+    name = "RaidManager" as "RaidManager";
 
     @Inject(IAdmin)
     private admin: IAdmin
     @Inject(ItemManager)
     private itemManager: IItemManager
 
+    @Inject(IPubSub)
+    private pubsub: IPubSub<any>
+
     exportRPCs = () => [
         this.getRaids,
         this.getRaidData,
                 this.startRaid,
                 this.adminUnsign
             ]
-        },{
+        }, {
             name: 'signup' as 'signup',
             exportRPCs: () => [
                 this.getSignups,
             ]
         }]
     }
-    
+
     getTableDefinitions(): TableDefiniton[] {
         return [
             {
                     table.integer('size').defaultTo(40)
                     table.string('tier').defaultTo('null')
                 }
-            },{
+            }, {
                 name: 'archive',
                 tableBuilder: (table) => {
                     table.integer('id').primary()
                     table.json('raiddata').notNullable()
                 }
-            },{
+            }, {
                 name: 'signups',
                 tableBuilder: (table) => {
                     table.increments('id').primary()
                     table.boolean('benched').defaultTo('false')
                     table.boolean('late')
                 }
-            }            
+            }
         ]
     }
 
-    createRaid = async (raid:Raid) : Promise<Raid>=> {
-        const ids:number[] = await this.admin
-        .knex('raids')
-        .insert(raid)
+    notifyRaid = async (raid:Raid | {id:number}) => {
+        const data = await this.getRaidData(<Raid>raid)
+        this.pubsub.publish(""+raid.id, data)
+        await this.notifyRaids()
+    }
 
-        return await this.admin.knex('raids').where({id: ids[0]}).first()
+    notifyRaids = async () => {
+        this.pubsub.publish('raids', undefined)
     }
 
-    addSignup = async (signup: Signup) => {
+    createRaid = async (raid: Raid): Promise<Raid> => {
+        const ids: number[] = await this.admin
+            .knex('raids')
+            .insert(raid)
 
-        const ids:number[] = await this.admin
-        .knex('signups')
-        .insert(signup)
-        return await this.admin.knex('signups').where({id: ids[0]}).first()
+        await this.notifyRaid({ id: ids[0] })
 
+        return await this.admin.knex('raids').where({ id: ids[0] }).first()
     }
 
-    removeSignup = async (signup: Signup) => await this.admin
-    .knex('signups')
-    .where({
-        raid_id: signup.raidid, 
-        character_id: signup.characterid
-    })
-    .del()
+    addSignup = async (signup: Signup) => {
 
-    getRaids = async () : Promise<Raid[]> => {
+        const ids: number[] = await this.admin
+            .knex('signups')
+            .insert(signup)
+        return await this.admin.knex('signups').where({ id: ids[0] }).first()
 
-        const subQuery = this.admin
+    }
+
+    removeSignup = async (signup: Signup) => await this.admin
         .knex('signups')
-        .count('*')
         .where({
-            raidid: this.admin.knex.ref('raids.id'),
-            benched: false,
-            late: false
+            raid_id: signup.raidid,
+            character_id: signup.characterid
         })
-        .as('signupcount')
-        
+        .del()
+
+    getRaids = async (): Promise<Raid[]> => {
+
+        const subQuery = this.admin
+            .knex('signups')
+            .count('*')
+            .where({
+                raidid: this.admin.knex.ref('raids.id'),
+                benched: false,
+                late: false
+            })
+            .as('signupcount')
+
         return await this.admin.knex('raids')
-        .select('*', subQuery)
-        .orderBy('start', 'asc')
+            .select('*', subQuery)
+            .orderBy('start', 'asc')
     }
 
-    startRaid = async (raid:Raid) : Promise<RaidData> => {
+    startRaid = async (raid: Raid): Promise<RaidData> => {
         const archived = await this.archiveRaid(raid)
-        
+
         const giveCurrency = async (b: Character) => {
             const usr = await this.characterManager.getUserOfCharacter(b)
             await this.userManager.incrementCurrency(usr, raid.tier, 1)
 
         await Promise.all([
             ...archived.participants.bench.map(giveCurrency),
-            ...Object.values(archived.participants).map((group: any) => group.map(giveCurrency))
+            ...Object.values(archived.participants).flat().flatMap((b:Signup & Character & Spec) => giveCurrency(b))
         ])
 
+        await this.notifyRaids()
+
         return archived
     }
 
-    archiveRaid = async (raid:Raid) : Promise<RaidData> => {
+    archiveRaid = async (raid: Raid): Promise<RaidData> => {
         const raidData = await this.getRaidData(raid)
 
         //const tx = await this.admin.knex.transaction()
 
         await this.admin.knex('archive')
-        //.transacting(tx)
-        .insert({
-            id:raidData.id,
-            raiddata: JSON.stringify(raidData)
-        })       
+            //.transacting(tx)
+            .insert({
+                id: raidData.id,
+                raiddata: JSON.stringify(raidData)
+            })
 
         await Promise.all(
-            Object.values(raidData.participants).flat().flatMap((signup) => this.admin
-                .knex(raid.tier+'tokens')
+            Object.values(raidData.participants).flat().flatMap((p: (Signup & Character & Spec)) => 
+                this.admin
+                .knex(raid.tier + 'tokens')
                 //.transacting(tx)
                 .where({
-                    characterid: signup.characterid,
+                    characterid: p.characterid,
                     signupid: null
                 })
                 .del()
-        ))
+            ))
 
         await this.admin.knex('raids')
-        //.transacting(tx)
-        .where('id', '=', raid.id)
-        .del()
+            //.transacting(tx)
+            .where('id', '=', raid.id)
+            .del()
         //await tx.commit()
 
-    
+
         const row = await this.admin.knex('archive')
-        .select('*')
-        .where({
-            id:raidData.id,
-        })
-        .first()
+            .select('*')
+            .where({
+                id: raidData.id,
+            })
+            .first()
         return JSON.parse(row.raiddata)
     }
 
-    getArchiveRaid = async(id:number) : Promise<RaidData> => {
+    getArchiveRaid = async (id: number): Promise<RaidData> => {
         const data = await this.admin.knex('archive').select('raiddata').where({
             id: id
         }).first()
-        
+
         return JSON.parse(data.raiddata)
     }
 
-    getPastRaids = async(limit: number) : Promise<RaidData[]> => {
+    getPastRaids = async (limit: number): Promise<RaidData[]> => {
         const raids = await this.admin.knex('archive')
-        .select('*')
-        .orderBy('id', 'desc')
-        .limit(limit)
+            .select('*')
+            .orderBy('id', 'desc')
+            .limit(limit)
 
         return raids.map(raid => JSON.parse(raid.raiddata))
     }
 
-    getRaidData = async (raid:Raid) : Promise<RaidData> => {
+    getRaidData = async (raid: Raid): Promise<RaidData> => {
         const raiddata = {
-            participants:{
-                Druid: <(Signup&Character&Spec)[]>[],
-                Hunter: <(Signup&Character&Spec)[]>[],
-                Mage: <(Signup&Character&Spec)[]>[],
-                Paladin: <(Signup&Character&Spec)[]>[],
-                Priest: <(Signup&Character&Spec)[]>[],
-                Rogue: <(Signup&Character&Spec)[]>[],
-                Shaman: <(Signup&Character&Spec)[]>[],
-                Warlock: <(Signup&Character&Spec)[]>[],
-                Warrior: <(Signup&Character&Spec)[]>[],
-                late: <(Signup&Character&Spec)[]>[],
-                bench: <(Signup&Character&Spec)[]>[],
+            participants: {
+                Druid: <(Signup & Character & Spec)[]>[],
+                Hunter: <(Signup & Character & Spec)[]>[],
+                Mage: <(Signup & Character & Spec)[]>[],
+                Paladin: <(Signup & Character & Spec)[]>[],
+                Priest: <(Signup & Character & Spec)[]>[],
+                Rogue: <(Signup & Character & Spec)[]>[],
+                Shaman: <(Signup & Character & Spec)[]>[],
+                Warlock: <(Signup & Character & Spec)[]>[],
+                Warrior: <(Signup & Character & Spec)[]>[],
+                late: <(Signup & Character & Spec)[]>[],
+                bench: <(Signup & Character & Spec)[]>[],
             },
-            tokens:{},
-            healers:<(Signup&Character&Spec)[]>[],
-            tanks:<(Signup&Character&Spec)[]>[]
+            tokens: {},
+            healers: <(Signup & Character & Spec)[]>[],
+            tanks: <(Signup & Character & Spec)[]>[]
         }
         //const tx = await this.admin.knex.transaction()
 
         const subQuery = this.admin
-        .knex('signups')
-        .count('*')
-        .where({
-            raidid: this.admin.knex.ref('raids.id'),
-            benched: false,
-            late: false
-        })
-        .as('signupcount')
+            .knex('signups')
+            .count('*')
+            .where({
+                raidid: this.admin.knex.ref('raids.id'),
+                benched: false,
+                late: false
+            })
+            .as('signupcount')
 
 
         const raidInDb: Raid = await this.admin.knex('raids')
-        .select('*', subQuery)
-        //.transacting(tx)
-        .where('id','=',raid.id)
-        .first()
+            .select('*', subQuery)
+            //.transacting(tx)
+            .where('id', '=', raid.id)
+            .first()
 
         const characterData: (Signup & Character & Spec)[] = await this.admin
-        .knex('signups as s')
-        //.transacting(tx)
-        .select('s.id as id', 'charactername', 'class', 'specid', 'specname', 'race', 'userid', 'benched', 'late', 'raidid', 'characterid', 'specid')
-        .join('raids as r', 's.raidid','=','r.id')
-        .join('characters as c', 's.characterid','=','c.id')
-        .join('users as u', 'c.userid','=','u.id')
-        .join('specs as sp', 'specid','=','sp.id')
-        .where('r.id','=',raid.id)
-        
+            .knex('signups as s')
+            //.transacting(tx)
+            .select('s.id as id', 'charactername', 'class', 'specid', 'specname', 'race', 'userid', 'benched', 'late', 'raidid', 'characterid', 'specid')
+            .join('raids as r', 's.raidid', '=', 'r.id')
+            .join('characters as c', 's.characterid', '=', 'c.id')
+            .join('users as u', 'c.userid', '=', 'u.id')
+            .join('specs as sp', 'specid', '=', 'sp.id')
+            .where('r.id', '=', raid.id)
+
         characterData.forEach(data => {
-            if(data.benched){
+            if (data.benched) {
                 raiddata.participants.bench.push(data)
                 return
             }
-            if(data.late){
+            if (data.late) {
                 raiddata.participants.late.push(data)
                 return
             }
         })
 
         const tokenData: (Character & SRToken & Item)[] = await this.admin
-        .knex('signups as s')
-        //.transacting(tx)
-        .select('*', 's.id as id')
-        .join('raids as r', 's.raidid','=','r.id')
-        .join('characters as c', 's.characterid','=','c.id')
-        .join(raidInDb.tier+'tokens as t', 't.characterid','=','c.id')
-        .join('items as i', 'i.itemname','=','t.itemname')
-        .where({
-            'r.id': raid.id,
-        })
-        .andWhere(function(){
-            this.whereNotNull('t.signupid')
-        })
+            .knex('signups as s')
+            //.transacting(tx)
+            .select('*', 's.id as id')
+            .join('raids as r', 's.raidid', '=', 'r.id')
+            .join('characters as c', 's.characterid', '=', 'c.id')
+            .join(raidInDb.tier + 'tokens as t', 't.characterid', '=', 'c.id')
+            .join('items as i', 'i.itemname', '=', 't.itemname')
+            .where({
+                'r.id': raid.id,
+            })
+            .andWhere(function () {
+                this.whereNotNull('t.signupid')
+            })
 
         //await tx.commit()
 
         tokenData.forEach(data => {
-            if(!raiddata.tokens[data.itemname])
+            if (!raiddata.tokens[data.itemname])
                 raiddata.tokens[data.itemname] = []
             raiddata.tokens[data.itemname].push(data)
         })
 
         raiddata.tanks = Object.values(raiddata.participants).flatMap(
-            (tanks:any[]) => tanks.filter((p:any) => 
-                !p.benched 
-                && !p.late 
-                && (p.specname==="Protection" 
-                    || p.specname==="Feral (Tank)"))
+            (tanks: any[]) => tanks.filter((p: any) =>
+                !p.benched
+                && !p.late
+                && (p.specname === "Protection"
+                    || p.specname === "Feral (Tank)"))
         )
         raiddata.healers = Object.values(raiddata.participants).flatMap(
-            (healers:any[]) => healers.filter((p:any) => 
-                !p.benched 
-                && !p.late 
-                && (p.specname==="Holy" 
-                    || p.specname==="Discipline" 
-                    || p.specname==="Restoration"))
+            (healers: any[]) => healers.filter((p: any) =>
+                !p.benched
+                && !p.late
+                && (p.specname === "Holy"
+                    || p.specname === "Discipline"
+                    || p.specname === "Restoration"))
         )
 
         return {
             ...raiddata
         }
     }
-    
-    getSignups = async (raid:Raid) : Promise<(Signup & Character & Spec & User)[]> => await this.admin
-    .knex('signups as si')
-    .join('characters as c', 'c.id', '=', 'characterid')
-    .join('specs as s', 's.id', '=', 'specid')
-    .join('users as u', 'u.id', '=', 'userid')
-    .select('*','si.id as id')
-    .where('raidid', '=', raid.id!)
-    
-    sign = async (usertoken:string, character:Character, raid:Raid, late:boolean) => {
+
+    getSignups = async (raid: Raid): Promise<(Signup & Character & Spec & User)[]> => await this.admin
+        .knex('signups as si')
+        .join('characters as c', 'c.id', '=', 'characterid')
+        .join('specs as s', 's.id', '=', 'specid')
+        .join('users as u', 'u.id', '=', 'userid')
+        .select('*', 'si.id as id')
+        .where('raidid', '=', raid.id!)
+
+    sign = async (usertoken: string, character: Character, raid: Raid, late: boolean) => {
         const maybeUserRecord = this.userManager.getUserRecordByToken(usertoken)
-        if(!maybeUserRecord || maybeUserRecord.user.id != character.userid){
+        if (!maybeUserRecord || maybeUserRecord.user.id != character.userid) {
             throw new Error("Bad Usertoken")
         }
         //const tx = await this.admin.knex.transaction()
 
         const exists = await this.admin
-        .knex('signups')
-        //.transacting(tx)
-        .select('*')
-        .where({
-            raidid: raid.id!,
-            characterid: character.id!,
-        })
-        .first()
-
-        if(!exists){
-            await this.admin
             .knex('signups')
             //.transacting(tx)
-            .insert({
+            .select('*')
+            .where({
                 raidid: raid.id!,
                 characterid: character.id!,
-                late: late,
-                benched: false,
             })
-        }else{
+            .first()
+
+        if (!exists) {
+            await this.admin
+                .knex('signups')
+                //.transacting(tx)
+                .insert({
+                    raidid: raid.id!,
+                    characterid: character.id!,
+                    late: late,
+                    benched: false,
+                })
+        } else {
             await this.admin
+                .knex('signups')
+                //.transacting(tx)
+                .where({
+                    id: exists.id
+                })
+                .update({
+                    raidid: raid.id!,
+                    characterid: character.id!,
+                    late: late,
+                    benched: false,
+                })
+        }
+        //await tx.commit()
+
+        await this.notifyRaid(raid)
+        
+        return await this.admin
             .knex('signups')
-            //.transacting(tx)
+            .select('*')
             .where({
-                id: exists.id 
-            })
-            .update({
                 raidid: raid.id!,
                 characterid: character.id!,
-                late: late,
-                benched: false,
             })
-        }
-        //await tx.commit()
-
-        return await this.admin
-        .knex('signups')
-        .select('*')
-        .where({
-            raidid: raid.id!,
-            characterid: character.id!,
-        })
-        .first()
+            .first()
     }
 
-    unsign = async (usertoken:string, character:Character, raid:Raid) => {
+    unsign = async (usertoken: string, character: Character, raid: Raid) => {
         const maybeUserRecord = this.userManager.getUserRecordByToken(usertoken)
-        if(!maybeUserRecord || maybeUserRecord.user.id != character.userid){
+        if (!maybeUserRecord || maybeUserRecord.user.id != character.userid) {
             throw new Error("Bad Usertoken")
         }
 
-        return await this.adminUnsign(character, raid)       
+        return await this.adminUnsign(character, raid)
     }
 
-    adminUnsign = async (character:Character, raid:Raid) => {
-        
+    adminUnsign = async (character: Character, raid: Raid) => {
+
         const user = await this.characterManager.getUserOfCharacter(character)
 
         const signup = await this.admin.knex('signups as si')
-        .where({
-            "si.raidid": raid.id!,
-            "si.characterid": character.id!,
-        }).first()
+            .where({
+                "si.raidid": raid.id!,
+                "si.characterid": character.id!,
+            }).first()
+
+        const tokens = await this.itemManager.getTokens(character, [raid.tier], true)
 
-        const tokens = await this.admin.knex(raid.tier+'tokens as t')
-        .where('t.signupid', signup.id)
-        
         //check if token has to be deleted
-        Promise.all(
-            tokens.map(async token => {
-                await this.userManager.incrementCurrency(user, raid.tier, 1)       
-                const prio = await this.itemManager.calculatePriorities(token.itemname, character)
-                if(token.level <= prio+1){
-                    await this.admin.knex(raid.tier+'tokens')
-                    .where({
-                        characterid: character.id,
-                        itemname: token.itemname
-                    }).del()
-                }else{
-                    await this.admin.knex(raid.tier+'tokens')
-                    .where({
-                        characterid: character.id,
-                        itemname: token.itemname
-                    }).update({
-                        signupid: null,
-                        level: token.level-1
-                    })
-                }
-            })
-        )
+        if (tokens) {
+            Promise.all(
+                tokens.map(async token => {
+                    await this.userManager.incrementCurrency(user, raid.tier, 1)
+                    const prio = await this.itemManager.calculatePriorities(token.itemname, character)
+                    if (token.level <= prio + 1) {
+                        await this.admin
+                            .knex(raid.tier + 'tokens')
+                            .where({
+                                characterid: character.id,
+                                itemname: token.itemname
+                            }).del()
+                    } else {
+                        await this.admin
+                            .knex(raid.tier + 'tokens')
+                            .where({
+                                characterid: character.id,
+                                itemname: token.itemname
+                            }).update({
+                                signupid: null,
+                                level: token.level - 1
+                            })
+                    }
+                })
+            )
+        }
 
         await this.admin.knex('signups')
-        .where({
-            raidid: raid.id!,
-            characterid: character.id!,
-        })
-        .del()
+            .where({
+                raidid: raid.id!,
+                characterid: character.id!,
+            })
+            .del()
+
+        await this.notifyRaid(raid)
     }
 
-    setBenched = async (signup: Signup) : Promise<void> => {
+    setBenched = async (signup: Signup): Promise<void> => {
         await this.admin.knex('signups')
-        .where({
-            raidid: signup.raidid,
-            characterid: signup.characterid
-        })
-        .update(signup)
+            .where({
+                raidid: signup.raidid,
+                characterid: signup.characterid
+            })
+            .update(signup)
+    
+        await this.notifyRaid({ id: signup.raidid })
     }
 }

src/backend/Components/User/UserManager.ts

         .where('id', '=', user.id)
         .update(tier, value)
     }
-
-
 }

src/backend/Injector/ServiceDecorator.ts

 import { Injector } from "./Injector";
 import { Type, GenericClassDecorator } from "./Util";
 import { FrontworkComponent } from "../Types/FrontworkComponent";
+import { RPCExporter } from "rpclibrary";
 
 /**
  * @returns {GenericClassDecorator<Type<any>>}
  */
 export const RootComponent = (config : {
     injectable : Type<any>
-    injects : Type<FrontworkComponent>[]
+    injects : Type<RPCExporter>[]
   }) : GenericClassDecorator<Type<any>> => {
   return (target: Type<any>) => {
     Injector.rootModules = config.injects

src/backend/Types/Types.ts

 import { GuildManagerFeatureIfc, GuildManagerIfc } from "../Components/Guild/RPCInterface";
 import { ShoutboxIfc } from "../Components/Shoutbox/RPCInterface";
 import { Tiers } from "./Items";
+import { PubSubIfc } from "../Components/PubSub/RPCInterface";
 
 export type FrontcraftIfc = RaidManagerIfc
                           & UserManagerIfc
                           & ItemManagerIfc
                           & GuildManagerIfc
                           & ShoutboxIfc
+                          & PubSubIfc
 
 export type FrontcraftFeatureIfc = RaidManagerFeatureIfc 
                                  & UserManagerFeatureIfc

src/frontend/package-lock.json

       "integrity": "sha512-ZYzRkETgBrdEGzL5JSKimvjI2CX7ioyZCkX2BpcfyjqI+079W0wHAyj5W4rIZMcDSOHgLZtgz1IdDi/vU77KEQ=="
     },
     "rpclibrary": {
-      "version": "1.6.2",
-      "resolved": "https://registry.npmjs.org/rpclibrary/-/rpclibrary-1.6.2.tgz",
-      "integrity": "sha512-lQTU4XkB9CSHz7YgtAcpVfyR5XrmTRX4P4eQjK6DDUjqKSFvJb5ChXjHnt1BcaNWbJ2VqmhCNVbcoyunJ2u7Rg==",
+      "version": "1.7.1",
+      "resolved": "https://registry.npmjs.org/rpclibrary/-/rpclibrary-1.7.1.tgz",
+      "integrity": "sha512-Ibo3qfURnQgZAq0eA2o+L9+PWaloJ4PHZs4ak42LL9fRgdWZXn33HAtowV0K2HVckbvrBvFqj/+PWTrWWBSOeg==",
       "requires": {
         "bsock": "^0.1.9",
         "http": "0.0.0",

src/frontend/package.json

     "normalize.css": "6.0.0",
     "pace-js": "1.0.2",
     "roboto-fontface": "0.8.0",
-    "rpclibrary": "^1.6.2",
+    "rpclibrary": "^1.7.1",
     "rxjs": "6.5.2",
     "rxjs-compat": "6.3.0",
     "socicon": "3.0.5",

src/frontend/src/app/frontcraft/pages/raid/raid.component.html

-<nb-card class="col-12 col-xl-9">
-    <nb-card-body>
-        <nb-tabset>
-            <nb-tab tabTitle="Info">
-                <h1>          
-                    <img [src]="'../../../../assets/images/'+(raid.tier || 'null').toLowerCase()+'.png'" style="height: 100px" />
-                    {{raid.title}}
-                </h1>
-                <p>
-                    {{raid.signupcount}} / {{raid.size}} signups
-                </p>
-                <p>
-                    {{raid.description}}
-                </p>
-                <div *ngIf="canSignup">
-                    <div *ngIf="isSignedup">
-
+<div class="row">
+    <div class="col-12 col-xl-6">
+        <nb-card  [size]="giant">
+            <nb-card-body>
+                <nb-tabset>
+                    <nb-tab tabTitle="Info">
+                        <h1>
+                            <img [src]="'../../../../assets/images/'+(raid.tier || 'null').toLowerCase()+'.png'"
+                                style="height: 100px" />
+                            {{raid.title}}
+                        </h1>
+                        <p>
+                            {{raid.signupcount}} / {{raid.size}} signups
+                        </p>
                         <p>
-                            You are signed as: {{mySignup.charactername}} ({{mySignup.race}} {{mySignup.specname}} {{mySignup.class}})<br />
-                            Status: {{mySignup.status}}
+                            {{raid.description}}
                         </p>
-                        
-                        <button
-                            (click)="setLate(true)"
-                            *ngIf="mySignup.status !== 'Late'"
-                            nbButton 
-                            outline 
-                            status="warning" 
-                            size="medium">
-                            <nb-icon icon="clock-outline"></nb-icon> Late
-                        </button>        
-                        <button
-                            (click)="setLate(false)"
-                            *ngIf="mySignup.status === 'Late'"
-                            nbButton 
-                            outline 
-                            status="success" 
-                            size="medium">
-                            <nb-icon icon="checkmark-outline"></nb-icon> On Time
-                        </button>  
-                        <button
-                            (click)="unsign()"
-                            nbButton 
-                            outline 
-                            status="danger" 
-                            size="medium">
-                            <nb-icon icon="close"></nb-icon>unsign
-                        </button>               
-                    </div>
-                    <div *ngIf="!isSignedup">
-                        <button
-                            (click)="signup()"
-                            nbButton 
-                            outline 
-                            status="success" 
-                            size="medium">
-                            <nb-icon icon="person-done-outline"></nb-icon> sign up
-                        </button>                     
-                    </div>
-                </div>
-            </nb-tab>
-            
-            <nb-tab tabTitle="Signups"
-              [badgeText]="raid.signupcount"
-              badgePosition="top right"
-              [badgeStatus]="raid.signupcount<40?'warning':'success'">
-                <div class="row">
-                    <nb-card
-                    class="col-12 col-md-6" 
-                    *ngIf="raid.tanks.length > 0">
-                        <nb-card-header>Tanks ({{raid.tanks.length}})</nb-card-header>
-                        <nb-card-body>
-                            <div *ngFor="let participant of raid.tanks">
-                                <button
-                                    (click)="setBench(participant)"
-                                    *ngIf="manageRaid" 
-                                    nbButton 
-                                    outline 
-                                    status="warning" 
-                                    size="tiny">
-                                    B
+                        <div *ngIf="canSignup">
+                            <div *ngIf="isSignedup">
+
+                                <p>
+                                    You are signed as: {{mySignup.charactername}} ({{mySignup.race}}
+                                    {{mySignup.specname}}
+                                    {{mySignup.class}})<br />
+                                    Status: {{mySignup.status}}
+                                </p>
+
+                                <button (click)="setLate(true)" *ngIf="mySignup.status !== 'Late'" nbButton outline
+                                    status="warning" size="medium">
+                                    <nb-icon icon="clock-outline"></nb-icon> Late
                                 </button>
-                                <button
-                                    (click)="adminUnsign(participant)"
-                                    *ngIf="manageRaid" 
-                                    nbButton 
-                                    outline 
-                                    status="danger" 
-                                    size="tiny">
-                                    X
+                                <button (click)="setLate(false)" *ngIf="mySignup.status === 'Late'" nbButton outline
+                                    status="success" size="medium">
+                                    <nb-icon icon="checkmark-outline"></nb-icon> On Time
                                 </button>
-                                <a [ngStyle]="{'color': participant.color}" style="text-transform: capitalize;" 
-                                [routerLink]="'/frontcraft/character/'+participant.charactername">
-                                <img style="width:20px; height:20px" [src]="'../../../../assets/images/'+participant.race.toLowerCase()+'_xs.gif'" />
-                                <img style="width:20px; height:20px" [src]="'../../../../assets/images/'+participant.class.toLowerCase()+'.png'" />
-                                {{ participant.charactername }}
-                                </a>
-                            </div>
-                        </nb-card-body>
-                    </nb-card>
-
-                    <nb-card
-                    class="col-12 col-md-6" 
-                    *ngIf="raid.tanks.length > 0">
-                        <nb-card-header>Healers ({{raid.healers.length}})</nb-card-header>
-                        <nb-card-body>
-                            <div *ngFor="let participant of raid.healers">
-                                <button
-                                    (click)="setBench(participant)"
-                                    *ngIf="manageRaid" 
-                                    nbButton 
-                                    outline 
-                                    status="warning" 
-                                    size="tiny">
-                                    B
+                                <button (click)="unsign()" nbButton outline status="danger" size="medium">
+                                    <nb-icon icon="close"></nb-icon>unsign
                                 </button>
-                                <button
-                                    (click)="adminUnsign(participant)"
-                                    *ngIf="manageRaid" 
-                                    nbButton 
-                                    outline 
-                                    status="danger" 
-                                    size="tiny">
-                                    X
+                            </div>
+                            <div *ngIf="!isSignedup">
+                                <button (click)="signup()" nbButton outline status="success" size="medium">
+                                    <nb-icon icon="person-done-outline"></nb-icon> sign up
                                 </button>
-                                <a [ngStyle]="{'color': participant.color}" style="text-transform: capitalize;" 
-                                [routerLink]="'/frontcraft/character/'+participant.charactername">
-                                <img style="width:20px; height:20px" [src]="'../../../../assets/images/'+participant.race.toLowerCase()+'_xs.gif'" />
-                                <img style="width:20px; height:20px" [src]="'../../../../assets/images/'+participant.class.toLowerCase()+'.png'" />
-                                {{ participant.charactername }}
-                                </a>
                             </div>
-                        </nb-card-body>
-                    </nb-card>
-
-                    <ng-container *ngFor="let group of raid.participants | keyvalue">
-                        <nb-card
-                        class="col-12 col-md-6 col-xl-4" 
-                        *ngIf="group.value.length > 0">
-                            <nb-card-header>{{group.key}} ({{group.value.length}})</nb-card-header>
-                            <nb-card-body>
-                                <div *ngFor="let participant of group.value">
-                                    <button
-                                        (click)="setBench(participant)"
-                                        *ngIf="manageRaid" 
-                                        nbButton 
-                                        outline 
-                                        status="warning" 
-                                        size="tiny">
-                                        B
-                                    </button>
-                                    <button
-                                        (click)="adminUnsign(participant)"
-                                        *ngIf="manageRaid" 
-                                        nbButton 
-                                        outline 
-                                        status="danger" 
-                                        size="tiny">
-                                        X
-                                    </button>
-                                    <a [ngStyle]="{'color': participant.color}" style="text-transform: capitalize;" 
-                                    [routerLink]="'/frontcraft/character/'+participant.charactername">
-                                    <img style="width:20px; height:20px" [src]="'../../../../assets/images/'+participant.race.toLowerCase()+'_xs.gif'" />
-                                    <img style="width:20px; height:20px" [src]="'../../../../assets/images/'+participant.class.toLowerCase()+'.png'" />
-                                    {{ participant.charactername }}
-                                    </a>
-                                </div>
-                            </nb-card-body>
-                        </nb-card>
-                    </ng-container>
-                </div>
-            </nb-tab>
-            <nb-tab tabTitle="Items" *ngIf="isSignedup && isTier">
-                <shop [tier]="raid.tier" (onSelect)="itemSelect($event)"></shop>
-            </nb-tab>
-            <nb-tab tabTitle="Reserves" *ngIf="isTier">
-                <input type="text" nbInput [(ngModel)]="search" (change)="changeSearch()" placeholder="Search" fullWidth="true">
+                        </div>
+                    </nb-tab>
+                    <nb-tab tabTitle="Signups" [badgeText]="raid.signupcount" badgePosition="top right"
+                        [badgeStatus]="raid.signupcount<40?'warning':'success'">
 
-                <nb-list>
-                    <nb-list-item *ngFor="let item of displayedtokens | keyvalue">
-                        <a [ngStyle]="{'color':item.value[0].quality=='Epic'?'#a335ee':'#ff8000'}" 
-                           target="_blank" 
-                           [href]="item.value[0].url">
-                           <img style="min-width: 25px; width: 2.25vw; max-width: 50px" 
-                           [src]="'https://wow.zamimg.com/images/wow/icons/large/'+item.value[0].iconname+'.jpg'" />
-                           &nbsp;
-                           {{item.key}}
-                        </a><br />
                         <div class="row">
-                            <div *ngFor="let token of item.value" class="col-12 col-md-6 col-xl-4">
-                                [ {{token.level}} ]  
-                                <span style="text-transform: capitalize;" [ngStyle]="{'color':token.level>=10?'#ff8000':token.level>=8?'#a335ee':token.level>=6?'#0070dd':token.level>=4?'#1eff00':token.level>=2?'#ffffff':'#9d9d9d'}">
-                                    {{token.charactername}}
-                                </span><br />
-                            </div>
+                            <nb-card class="col-12 col-md-6" *ngIf="raid.tanks.length > 0">
+                                <nb-card-header>Tanks ({{raid.tanks.length}})</nb-card-header>
+                                <nb-card-body>
+                                    <div *ngFor="let participant of raid.tanks">
+                                        <button (click)="setBench(participant)" *ngIf="manageRaid" nbButton outline
+                                            status="warning" size="tiny">
+                                            B
+                                        </button>
+                                        <button (click)="adminUnsign(participant)" *ngIf="manageRaid" nbButton outline
+                                            status="danger" size="tiny">
+                                            X
+                                        </button>
+                                        <a [ngStyle]="{'color': participant.color}" style="text-transform: capitalize;"
+                                            [routerLink]="'/frontcraft/character/'+participant.charactername">
+                                            <img style="width:20px; height:20px"
+                                                [src]="'../../../../assets/images/'+participant.race.toLowerCase()+'_xs.gif'" />
+                                            <img style="width:20px; height:20px"
+                                                [src]="'../../../../assets/images/'+participant.class.toLowerCase()+'.png'" />
+                                            {{ participant.charactername }}
+                                        </a>
+                                    </div>
+                                </nb-card-body>
+                            </nb-card>
+
+                            <nb-card class="col-12 col-md-6" *ngIf="raid.tanks.length > 0">
+                                <nb-card-header>Healers ({{raid.healers.length}})</nb-card-header>
+                                <nb-card-body>
+                                    <div *ngFor="let participant of raid.healers">
+                                        <button (click)="setBench(participant)" *ngIf="manageRaid" nbButton outline
+                                            status="warning" size="tiny">
+                                            B
+                                        </button>
+                                        <button (click)="adminUnsign(participant)" *ngIf="manageRaid" nbButton outline
+                                            status="danger" size="tiny">
+                                            X
+                                        </button>
+                                        <a [ngStyle]="{'color': participant.color}" style="text-transform: capitalize;"
+                                            [routerLink]="'/frontcraft/character/'+participant.charactername">
+                                            <img style="width:20px; height:20px"
+                                                [src]="'../../../../assets/images/'+participant.race.toLowerCase()+'_xs.gif'" />
+                                            <img style="width:20px; height:20px"
+                                                [src]="'../../../../assets/images/'+participant.class.toLowerCase()+'.png'" />
+                                            {{ participant.charactername }}
+                                        </a>
+                                    </div>
+                                </nb-card-body>
+                            </nb-card>
+
+                            <ng-container *ngFor="let group of raid.participants | keyvalue">
+                                <nb-card class="col-12 col-md-6 col-xl-4" *ngIf="group.value.length > 0">
+                                    <nb-card-header>{{group.key}} ({{group.value.length}})</nb-card-header>
+                                    <nb-card-body>
+                                        <div *ngFor="let participant of group.value">
+                                            <button (click)="setBench(participant)" *ngIf="manageRaid" nbButton outline
+                                                status="warning" size="tiny">
+                                                B
+                                            </button>
+                                            <button (click)="adminUnsign(participant)" *ngIf="manageRaid" nbButton
+                                                outline status="danger" size="tiny">
+                                                X
+                                            </button>
+                                            <a [ngStyle]="{'color': participant.color}"
+                                                style="text-transform: capitalize;"
+                                                [routerLink]="'/frontcraft/character/'+participant.charactername">
+                                                <img style="width:20px; height:20px"
+                                                    [src]="'../../../../assets/images/'+participant.race.toLowerCase()+'_xs.gif'" />
+                                                <img style="width:20px; height:20px"
+                                                    [src]="'../../../../assets/images/'+participant.class.toLowerCase()+'.png'" />
+                                                {{ participant.charactername }}
+                                            </a>
+                                        </div>
+                                    </nb-card-body>
+                                </nb-card>
+                            </ng-container>
                         </div>
-                    </nb-list-item>
-                </nb-list>
-            </nb-tab>
-            <nb-tab tabTitle="Admin" *ngIf="manageRaid">
-                <button
-                    (click)="startRaid(raid)"
-                    nbButton 
-                    outline 
-                    status="success" 
-                    size="medium">
-                    start
-                </button>
-            </nb-tab>
-        </nb-tabset>
-    </nb-card-body>
-</nb-card>
+                    </nb-tab>
+                    <nb-tab tabTitle="Admin" *ngIf="manageRaid">
+                        <button (click)="startRaid(raid)" nbButton outline status="success" size="medium">
+                            start
+                        </button>
+                    </nb-tab>
+                </nb-tabset>
+            </nb-card-body>
+        </nb-card>
+    </div>
+    <div class="col-12 col-xl-6">
+        <nb-card  *ngIf="isTier">
+            <nb-card-body>
+                <nb-tabset>
+                    <nb-tab tabTitle="Reserves">
+                        <input type="text" nbInput [(ngModel)]="search" (change)="changeSearch()" placeholder="Search"
+                            fullWidth="true">
 
+                        <nb-list>
+                            <nb-list-item *ngFor="let item of displayedtokens | keyvalue">
+                                <a [ngStyle]="{'color':item.value[0].quality=='Epic'?'#a335ee':'#ff8000'}"
+                                    target="_blank" [href]="item.value[0].url">
+                                    <img style="min-width: 25px; width: 2.25vw; max-width: 50px"
+                                        [src]="'https://wow.zamimg.com/images/wow/icons/large/'+item.value[0].iconname+'.jpg'" />
+                                    &nbsp;
+                                    {{item.key}}
+                                </a><br />
+                                <div class="row">
+                                    <div *ngFor="let token of item.value" class="col-12 col-md-6 col-xl-4">
+                                        [ {{token.level}} ]
+                                        <span style="text-transform: capitalize;"
+                                            [ngStyle]="{'color':token.level>=10?'#ff8000':token.level>=8?'#a335ee':token.level>=6?'#0070dd':token.level>=4?'#1eff00':token.level>=2?'#ffffff':'#9d9d9d'}">
+                                            {{token.charactername}}
+                                        </span><br />
+                                    </div>
+                                </div>
+                            </nb-list-item>
+                        </nb-list>
+                    </nb-tab>
+                    <nb-tab tabTitle="Items" *ngIf="isSignedup">
+                        <shop [tier]="raid.tier" (onSelect)="itemSelect($event)"></shop>
+                    </nb-tab>
+                </nb-tabset>
+            </nb-card-body>
+        </nb-card>
+    </div>
+</div>

src/frontend/src/app/frontcraft/pages/raid/raid.component.ts

-import { Component, OnInit } from '@angular/core';
-import { ActivatedRoute, Router } from '@angular/router';
+import { Component, OnInit, OnDestroy } from '@angular/core';
+import { ActivatedRoute, Router, NavigationStart } from '@angular/router';
 import { ApiService as ApiService } from '../../services/login-api';
 import { RaidData, Raid, Signup, Character, Spec, Item, SRToken } from '../../../../../../backend/Types/Types';
 import { NbWindowService, NbToastrService, NbDialogService } from '@nebular/theme';
   selector: 'raid',
   templateUrl: './raid.component.html',
 })
-export class FrontcraftRaidComponent implements OnInit{
+export class FrontcraftRaidComponent implements OnInit, OnDestroy{
 
     canSignup = false
     isSignedup = false
     tokens = {}
     displayedtokens = {}
     search = ""
+    uuid
 
     constructor(
       private api: ApiService,
       private toast: NbToastrService
     ){
       window['r'] = this
+      router.events.subscribe(event => {
+        if (event instanceof NavigationStart) {
+          this.ngOnDestroy()
+        }
+      })
+    }
+
+    ngOnDestroy = () => {
+      if(this.uuid)
+        this.api.get('PubSub').unsubscribe(this.uuid)
     }
 
     async ngOnInit(){
       if(signupFeature){
         this.canSignup = true
       }
-      this.refresh()
+      await this.refresh()
+
+      const res = await this.api.get('PubSub').subscribe(""+this.raid.id!, (data: RaidData) => {
+        this.display(data)
+      })
+      this.uuid = res.uuid
     }
 
+ 
+
     itemSelect = async(item) => {
       this.dialogService.open(FrontcraftBuyTokenComponent, {
         context: {
           tier: this.raid.tier,
           characterName: this.mySignup.charactername
         }
-      }).onClose.subscribe(() => this.refresh())
+      })
     }
 
     signup = async () => {
         context: {
           raid: this.raid,
         } 
-      }).onClose.subscribe(()=>{
-        this.refresh()
-      });
+      })
     }
 
     async archiveRaid(raid:Raid){
         id: this.mySignup.characterid, 
       }, this.raid)
       this.toast.show('Success', 'Unsigned', { status: 'success' })
-      this.refresh()
     }
 
     setLate = async (value:boolean) => {
         id: this.mySignup.characterid,
       }, this.raid, value)
       this.toast.show('Signup', 'Success', { status: 'success' })
-      this.refresh()
     }
 
     adminUnsign = async() => {
         ...this.mySignup,
         id: this.mySignup.characterid, 
       }, this.raid)
-      this.refresh()
     }
 
     refresh = async () => {
       const raiddata = await raidManager.getRaidData(<any>{
         id: param
       })
+      this.display(raiddata)
+      
+    }
+
+    display =  async (raiddata:RaidData)  => {
       this.isTier = allItems[raiddata.tier] != null
 
       this.raid = raiddata

src/frontend/src/app/frontcraft/pages/raids/raids.component.html

     class="raidlist"
     style="cursor: pointer;">
       <div class="row">
-        <div class="col-2">
-          <img [src]="'../../../../assets/images/'+(raid.tier || 'null').toLowerCase()+'.png'" style="height: 75px" />
-        </div>
-
-        <div class="col-2 vcenter">
-          {{raid.title}}
-         </div>
-        
-        <div class="col-2 vcenter">
-          <nb-icon icon="checkmark-circle"></nb-icon> {{raid.signupcount}} / {{raid.size}}<br>
-        </div>
-
-        <div class="col-2 vcenter">
-          <nb-icon icon="clock-outline"></nb-icon> {{raid.start | date : 'HH:mm'}}
-        </div>
+        <img [src]="'../../../../assets/images/'+(raid.tier || 'null').toLowerCase()+'.png'" 
+        style="object-fit: contain"
+        class="col-1 col-s-3" />
 
-        <div class="col-4 vcenter">
-          <nb-icon icon="calendar-outline"></nb-icon> {{raid.start | date : 'EEEE MMMM d'}}
+        <div class="col-11 col-s-9" >
+          <div class="row">
+            <div class="col-12" style="padding-top: 5px">
+              <h4>
+                {{raid.title}}
+              </h4>
+            </div>
+          </div>
+          <div class="row" style="padding-top: 5px; padding-bottom: 5px; color:darkgray">
+            <div class="col-6 col-md-3">
+              <nb-icon icon="checkmark-circle"></nb-icon> {{raid.signupcount}} / {{raid.size}}<br>
+            </div>
+    
+            <div class="col-6 col-md-3">
+              <nb-icon icon="clock-outline"></nb-icon> {{raid.start | date : 'HH:mm'}}
+            </div>
+    
+            <div class="col-12 col-md-6">
+              <nb-icon icon="calendar-outline"></nb-icon> {{raid.start | date : 'EEE MMM d'}}
+            </div>
+          </div>
         </div>
       </div>
     </nb-list-item>

src/frontend/src/app/frontcraft/pages/raids/raids.component.scss

   background-color: #293259;
 }
 
-.vcenter {
-  height: 75px;
-  padding-top: 30px;
+.raid {
+  height: 75px
+}
+
+.row {
+  margin: -0.5rem;
+}
+
+h4 {
+  font-weight: normal
 }

src/frontend/src/app/frontcraft/pages/raids/raids.component.ts

-import { Component, OnInit } from '@angular/core';
+import { Component, OnInit, OnDestroy } from '@angular/core';
 import { ApiService } from '../../services/login-api';
 import { NbWindowService, NbDialogService } from '@nebular/theme';
 import { FrontcraftCreateRaidsComponent } from './createraid.compontent';
+import { Router, NavigationStart } from '@angular/router';
 
 @Component({
   selector: 'raids',
   templateUrl: 'raids.component.html',
   styleUrls: ['raids.component.scss'],
 })
-export class FrontcraftRaidsComponent implements OnInit{
+export class FrontcraftRaidsComponent implements OnInit, OnDestroy{
 
 
   manageRaid
   raids = []
   oldraids = []
   pageSize = 10;
+  uuid
 
   constructor(
     private api: ApiService,
+    private router: Router,
     private dialogService: NbDialogService
   ) {
     this.manageRaid = this.api.get('manageRaid')
+    router.events.subscribe(event => {
+      if (event instanceof NavigationStart) {
+        this.ngOnDestroy()
+      }
+    })
+  }
 
+  ngOnDestroy = () => {
+    console.log("boom");
+
+    if(this.uuid)
+      this.api.get('PubSub').unsubscribe(this.uuid)
   }
 
-  ngOnInit(): void {
+  async ngOnInit() {
+    const res = await this.api.get('PubSub').subscribe("raids", () => {
+      this.refresh()
+    })
+    this.uuid = res.uuid
     this.refresh()
   }
 
       context: {
         templates: this.oldraids
       } 
-    }).onClose.subscribe(()=>{
-      this.refresh()
-    });
+    })
 
   }
 }

src/frontend/src/app/frontcraft/pages/rules/rules.component.html

     <nb-card-body>
         <nb-tabset>
             <nb-tab tabTitle="Info">
-                Smart text here
+                <h3>How it works</h3>
+                <ul>
+                    <li>
+                        Everyone starts out with 1 soft reserve right per raid tier (you can see them in your user profile)
+                    </li>
+                    <li>
+                        The tiers are: MC+Ony, BWL, ZG, AQ20, AQ40, Naxx
+                    </li>
+                    <li>
+                        You gain 1 reserve right for a raid you attend. 2 if you were benched. Rights are granted on raid start.
+                    </li>
+                    <li>
+                        When you sign up to a raid you can spend your reserve rights
+                    </li>
+                    <li>
+                        Every week you can re-reserve the same item to build a streak on it
+                    </li>
+                    <!--
+                    <li>
+                        Steaks are color coded. If this means anything will be decided by guild culture: 
+                        <span style="color: #ff8000">[+ 10]</span>
+                        <span style="color: #a335ee">[9. 8]</span>
+                        <span style="color: #0070dd">[7, 6]</span>
+                        <span style="color: #1eff00">[5, 4]</span>
+                        <span style="color: #ffffff">[3, 2]</span>
+                        <span style="color: #9d9d9d">[1]</span>
+                    </li>
+                    -->
+                </ul>
+                <br />
+                <h3>Specifics about streaks</h3>
+                <ul>
+                    <li>
+                        Some classes and races get an initial boost to specific reserves. The list is on the second tab. 
+                    </li>
+                    <li>
+                        Switching the selected item destroys previous streaks. (Streaks must be continued without switchup)    
+                    </li>
+                    <li>
+                        If you have more than 1 softreserve you can reserve multiple different items. You may only continue one streak the following raid.
+                    </li>
+                    <li>
+                        If you have more than 1 softreserve you can reserve the same item several times to increase its streak.
+                    </li>
+                    <li>
+                        The softreserve counter, Reserves, and Streaks are tiers-specific and only count within their tier.
+                    </li>
+                    <li>
+                        Canceling the signup refunds active reserves and continued streaks. Destroyed streaks cannot be recovered. 
+                    </li>
+                </ul>
             </nb-tab>
             <nb-tab tabTitle="priorities">
                 <nb-list>
                     <nb-list-item *ngFor="let item of rules | keyvalue">
                         <wowhead [item]="item.value[0]"></wowhead><br>
-                        <span *ngFor="let rule of item.value" [nbPopover]="templateRef" nbPopoverTrigger="hover">
-                            <ng-template #templateRef>
-                                <span style="color:white">{{rule.description}}</span>
-                            </ng-template>
-                            <span *ngIf="rule.modifier>0">+</span>{{rule.modifier}} {{rule.race}} <span [ngStyle]="{'color':rule.color}">{{rule.specname}} {{rule.class}}</span> <br />
-                        </span>
+                        <div class="row" *ngFor="let rule of item.value">
+                            <div class="col-4">
+                                <span *ngIf="rule.modifier>0">+</span>{{rule.modifier}} {{rule.race}} <span [ngStyle]="{'color':rule.color}">{{rule.specname}} {{rule.class}}</span> 
+                            </div>
+                            <div class="col-8" style="color:white"> ({{rule.description}})</div>
+                            <br />
+                        </div>
                     </nb-list-item>
                 </nb-list>
             </nb-tab>

test/backendTest.ts

 import { Injector } from "../src/backend/Injector/Injector";
 import { FrontworkAdmin } from "../src/backend/Admin/Admin";
-import { T1 } from "../src/backend/Types/Items";
+import { T1, T2, Tiers } from "../src/backend/Types/Items";
 
 import { RPCSocket } from "rpclibrary";
 import { FrontcraftIfc, Auth, User, FrontcraftFeatureIfc, Raid, Character, Rank, Class, Race, SRPriority, Spec, Signup } from "../src/backend/Types/Types";
 
 
 type protoAccount<C extends Class = Class> = {
-    name : string,
+    name: string,
     pwHash?: string
-    rank : Rank,
+    rank: Rank,
     race: Race,
     class: C,
     spec: SpecT[C]
 }
 
 const defaultPermissions = [
-{   rpcname: 'signup', ...trialsAndUp
-},{ rpcname: 'reset', ...adminsOnly 
-},{ rpcname: 'modifyPermissions', ...adminsOnly 
-},{ rpcname: 'manageGuild', ...adminsOnly
-},{ rpcname: 'managePriorities', ...adminsOnly
-},{ rpcname: 'softreserveCurrency', ...adminsOnly
-},{ rpcname: 'manageRaid', ...adminsOnly
-}]
-
-const testAccounts : protoAccount[] = [
+    {
+        rpcname: 'signup', ...trialsAndUp
+    }, {
+        rpcname: 'reset', ...adminsOnly
+    }, {
+        rpcname: 'modifyPermissions', ...adminsOnly
+    }, {
+        rpcname: 'manageGuild', ...adminsOnly
+    }, {
+        rpcname: 'managePriorities', ...adminsOnly
+    }, {
+        rpcname: 'softreserveCurrency', ...adminsOnly
+    }, {
+        rpcname: 'manageRaid', ...adminsOnly
+    }]
+
+const testAccounts: protoAccount[] = [
     {
         name: 'Rain',
         race: 'Human',
         class: 'Warrior',
         spec: 'Protection',
         rank: 'Guildmaster'
-    },{
+    }, {
         name: 'Celinda',
         class: 'Warrior',
         race: 'Night Elf',
         spec: 'Protection',
         rank: 'Officer'
-    },{
+    }, {
         name: 'Silver',
         class: 'Druid',
         race: 'Night Elf',
         spec: 'Restoration',
         rank: 'Raider'
-    },{
+    }, {
         name: 'Dagger',
         race: 'Dwarf',
         class: 'Rogue',
         spec: 'Assassination',
         rank: 'Classleader'
-    },{
+    }, {
         name: 'Hope',
         class: 'Paladin',
         race: 'Human',
         spec: 'Holy',
         rank: 'Classleader'
-    },{
+    }, {
         name: 'Shrekd',
         class: 'Warrior',
         race: 'Dwarf',
         spec: 'Fury',
         rank: 'Classleader'
-    },{
+    }, {
         name: 'Teeniweeni',
         class: 'Warlock',
         race: 'Gnome',
         spec: 'Demonology',
         rank: 'Classleader'
-    },{
+    }, {
         name: 'Hagibaba',
         class: 'Priest',
         race: 'Human',
         spec: 'Discipline',
         rank: 'Classleader'
-    },{
+    }, {
         name: 'Muffinbreak',
         class: 'Mage',
         race: 'Gnome',
 
 describe('Frontcraft', () => {
     let auth: Auth,
-        adminUser : User,
+        adminUser: User,
         server: FrontworkAdmin,
-        client : RPCSocket & FrontcraftIfc,
-        adminClient : RPCSocket & FrontcraftFeatureIfc,
+        client: RPCSocket & FrontcraftIfc,
+        adminClient: RPCSocket & FrontcraftFeatureIfc,
         raids: Raid[] = [],
-        users : {[username in string] : { account: User, character: Character, auth: Auth, signup?:Signup, item?:string }} = {}
+        users: { [username in string]: { account: User, character: Character, auth: Auth, signup?: Signup, item?: string } } = {}
 
     const createAccount = (user: User) => {
         return client.UserManager.createUser(user)
     }
 
-    const createAccountAndUser = async (acc : protoAccount) => {
+    const createAccountAndUser = async (acc: protoAccount) => {
         const account = await createAccount({
             pwhash: 'ca978112ca1bbdcafac231b39a23dc4da786eff8147c4e72b9807785afee48bb', //sha256("a")
             rank: acc.rank,
         }
     }
 
-    before(function (done){
-        this.timeout(10000); 
+    before(function (done) {
+        this.timeout(10000);
 
         server = Injector.resolve<FrontworkAdmin>(FrontworkAdmin)
         server.start().then((_server) => {
-            
+
             RPCSocket.makeSocket<FrontcraftIfc>(20000, 'localhost').then(_client => {
                 client = _client
-                
+
 
                 createAccount({
                     pwhash: 'ca978112ca1bbdcafac231b39a23dc4da786eff8147c4e72b9807785afee48bb', //hash("a")
 
                     client.UserManager.login(adminUser.username, 'ca978112ca1bbdcafac231b39a23dc4da786eff8147c4e72b9807785afee48bb').then(auth => {
                         const sock = new RPCSocket(
-                            auth.port, 
+                            auth.port,
                             "localhost"
                         )
 
                                 console.log("I got kicked");
                             })
                             sock.hook('getUserData', () => auth)
-                            sock.hook('navigate', (where:string) => {
-                                console.log("Nagivate client to "+where);
+                            sock.hook('navigate', (where: string) => {
+                                console.log("Nagivate client to " + where);
                             })
                             sock.on('error', (e) => {
-                                console.log('Socket error',  e)
+                                console.log('Socket error', e)
                             })
                             done()
                         })
         }).catch(done)
     })
 
-    after(()=>{
+    after(() => {
         client.destroy()
         adminClient.destroy()
         server.stop()
     it('create raids', (done) => {
         let insertRaid = <Raid>{
             description: "Test raid 1",
-            title: 'MC',
+            title: 'BWL :D',
             start: Date.now().toString(),
-            tier: 'MC'
+            tier: 'BWL'
         }
 
         adminClient.manageRaid.createRaid(insertRaid).then(() => {
-            client.RaidManager.getRaids().then((r)=>{
-                if(r[0].title === insertRaid.title 
-                && r[0].description === insertRaid.description
-                && r[0].tier === "MC"){
+            client.RaidManager.getRaids().then((r) => {
+                if (r[0].title === insertRaid.title
+                    && r[0].description === insertRaid.description
+                    && r[0].tier === "BWL") {
                     raids.push(r[0])
                     done()
                 }
         }).catch(done)
     })
 
-    it('create users', (done)=>{
+    it('create users', (done) => {
         Promise.all(testAccounts.map(acc => createAccountAndUser(acc))).then(accs => {
-            if(accs.length === testAccounts.length){
+            if (accs.length === testAccounts.length) {
                 accs.forEach(acc => {
                     users[acc.account.username] = acc
                 })
         }).catch(done)
     })
 
-    it('should sign up', (done)=>{
+    it('should sign up', (done) => {
         Promise.all(Object.values(users).map((user) =>
             adminClient.signup.sign(user.auth.token.value, user.character, raids[0], false).catch(done)
         )).then(x => {
             adminClient.signup.getSignups(raids[0]).then(s => {
-                if(s.length == testAccounts.length){
+                if (s.length == testAccounts.length) {
                     s.forEach(sign => {
                         users[sign.username].signup = sign
                     })
                     done()
-                }else{
-                    done("Unexpected number of signups: "+s.length)
+                } else {
+                    done("Unexpected number of signups: " + s.length)
                 }
             })
         })
     })
 
-    it('calculate priorities', (done)=>{
-        const makePrio = async (itemname:string, spec?: Spec, race?:Race, mod:number = 0, description:string = "") => {
+    it('calculate priorities', (done) => {
+        const makePrio = async (itemname: string, spec?: Spec, race?: Race, mod: number = 0, description: string = "") => {
             let specid
-            if(spec)
+            if (spec)
                 specid = await client.CharacterManager.getSpecId(spec.class, <any>spec.specname)
-            
+
             await adminClient.managePriorities.setPriority(itemname, {
                 specid: specid,
                 race: race,
             })
         }
 
-              
+
         Promise.all([
             makePrio(
-                'Bracers of Arcane Accuracy', 
-                {class:'Warlock', specname:'Demonology'}, 
+                'Bracers of Arcane Accuracy',
+                { class: 'Warlock', specname: 'Demonology' },
                 undefined, 2, "hit bias"
             ),
             makePrio(
-                'Bracers of Arcane Accuracy', 
-                {class:'Warlock', specname:'Affliction'}, 
+                'Bracers of Arcane Accuracy',
+                { class: 'Warlock', specname: 'Affliction' },
                 undefined, 2, "hit bias"
             ),
             makePrio(
-                'Bracers of Arcane Accuracy', 
-                {class:'Warlock', specname:'Destruction'}, 
+                'Bracers of Arcane Accuracy',
+                { class: 'Warlock', specname: 'Destruction' },
                 undefined, 2, "hit bias"
             ),
             makePrio(
-                'Bracers of Arcane Accuracy', 
-                {class:'Mage', specname:'Arcane'}, 
+                'Bracers of Arcane Accuracy',
+                { class: 'Mage', specname: 'Arcane' },
                 undefined, 1, "hit bias"
             ),
             makePrio(
-                'Bracers of Arcane Accuracy', 
-                {class:'Mage', specname:'Frost'}, 
+                'Bracers of Arcane Accuracy',
+                { class: 'Mage', specname: 'Frost' },
                 undefined, 1, "hit bias"
             ),
             makePrio(
-                'Bracers of Arcane Accuracy', 
-                {class:'Mage', specname:'Fire'}, 
+                'Bracers of Arcane Accuracy',
+                { class: 'Mage', specname: 'Fire' },
                 undefined, 1, "hit bias"
             ),
 
             makePrio(
-                'Maladath, Runed Blade of the Black Flight', 
+                'Maladath, Runed Blade of the Black Flight',
                 undefined,
-                "Human", -2, "(1) Non-Human"
-            ),
-            makePrio(
-                'Maladath, Runed Blade of the Black Flight', 
-                {class:'Rogue', specname:'Subtlety'}, 
-                undefined, 2, "...Rogues (weapon skill bias)"
+                "Human", -2, "[1] Non-Human"
             ),
             makePrio(
-                'Maladath, Runed Blade of the Black Flight', 
-                {class:'Rogue', specname:'Combat'}, 
-                undefined, 2, "...Rogues (weapon skill bias)"
+                'Maladath, Runed Blade of the Black Flight',
+                { class: 'Rogue', specname: 'Combat' },
+                undefined, 2, "Weapon skill bias"
             ),
             makePrio(
-                'Maladath, Runed Blade of the Black Flight', 
-                {class:'Rogue', specname:'Assassination'}, 
-                undefined, 2, "...Rogues (weapon skill bias)"
+                'Maladath, Runed Blade of the Black Flight',
+                { class: 'Warrior', specname: 'Fury' },
+                'Human', 4, "+2 Fury Warrior (weapon skill bias), +2 to offset [1]"
             ),
             makePrio(
-                'Maladath, Runed Blade of the Black Flight', 
-                {class:'Warrior', specname:'Fury'}, 
-                'Human', 4, "+2 Fury Warrior (weapon skill bias), +2 to offset (1)"
+                'Maladath, Runed Blade of the Black Flight',
+                { class: 'Warrior', specname: 'Protection' },
+                'Human', 5, "+3 Prot Warrior, +2 to offset [1]"
             ),
 
             makePrio(
-                'Cloak of Firemaw', 
-                {class:'Rogue', specname:'Assassination'}, 
+                'Cloak of Firemaw',
+                { class: 'Rogue', specname: 'Assassination' },
                 undefined, 2, "agi-to-ap bias"
             ),
             makePrio(
-                'Cloak of Firemaw', 
-                {class:'Rogue', specname:'Combat'}, 
+                'Cloak of Firemaw',
+                { class: 'Rogue', specname: 'Combat' },
                 undefined, 2, "agi-to-ap bias"
             ),
             makePrio(
-                'Cloak of Firemaw', 
-                {class:'Rogue', specname:'Subtlety'}, 
+                'Cloak of Firemaw',
+                { class: 'Rogue', specname: 'Subtlety' },
                 undefined, 2, "agi-to-ap bias"
             ),
 
             makePrio(
-                'Band of Forced Concentration', 
-                {class:'Warlock', specname:'Demonology'}, 
+                'Band of Forced Concentration',
+                { class: 'Warlock', specname: 'Demonology' },
                 undefined, 2, "hit bias"
             ),
             makePrio(
-                'Band of Forced Concentration', 
-                {class:'Warlock', specname:'Affliction'}, 
+                'Band of Forced Concentration',
+                { class: 'Warlock', specname: 'Affliction' },
                 undefined, 2, "hit bias"
             ),
             makePrio(
-                'Band of Forced Concentration', 
-                {class:'Warlock', specname:'Destruction'}, 
+                'Band of Forced Concentration',
+                { class: 'Warlock', specname: 'Destruction' },
                 undefined, 2, "hit bias"
             ),
             makePrio(
-                'Band of Forced Concentration', 
-                {class:'Mage', specname:'Arcane'}, 
+                'Band of Forced Concentration',
+                { class: 'Mage', specname: 'Arcane' },
                 undefined, 1, "hit bias"
             ),
             makePrio(
-                'Band of Forced Concentration', 
-                {class:'Mage', specname:'Frost'}, 
+                'Band of Forced Concentration',
+                { class: 'Mage', specname: 'Frost' },
                 undefined, 1, "hit bias"
             ),
             makePrio(
-                'Band of Forced Concentration', 
-                {class:'Mage', specname:'Fire'}, 
+                'Band of Forced Concentration',
+                { class: 'Mage', specname: 'Fire' },
                 undefined, 1, "hit bias"
             ),
 
             makePrio(
-                'Drake Fang Talisman', 
-                {class:'Rogue', specname:'Assassination'}, 
+                'Chromatic Boots',
+                { class: 'Warrior', specname: 'Protection' },
+                undefined, 2, "hit bias"
+            ),
+
+            makePrio(
+                'Crul\'shorukh, Edge of Chaos',
+                undefined,
+                "Human", -2, "Non-human"
+            ),
+            makePrio(
+                'Crul\'shorukh, Edge of Chaos',
+                { class: 'Warrior', specname: 'Protection' },
+                undefined, 2, "nice dps bias"
+            ),
+            makePrio(
+                'Crul\'shorukh, Edge of Chaos',
+                { class: 'Warrior', specname: 'Fury' },
+                undefined, 2, "nice dps bias"
+            ),
+
+            makePrio(
+                'Drake Talon Pauldrons',
+                { class: 'Warrior', specname:'Protection'},
+                undefined, 2, 'dodge + stats-to-threat bias'
+            ),
+            
+            makePrio(
+                'Helm of Endless Rage',
+                { class: 'Warrior', specname:'Protection'},
+                undefined, 2, 'stats-to-threat bias'
+            ),
+
+            makePrio(
+                'Drake Fang Talisman',
+                { class: 'Warrior', specname: 'Protection' },
+                undefined, 5, "hit bias"
+            ),
+            makePrio(
+                'Drake Fang Talisman',
+                { class: 'Rogue', specname: 'Assassination' },
                 undefined, 4, "hit bias"
             ),
             makePrio(
-                'Drake Fang Talisman', 
-                {class:'Rogue', specname:'Combat'}, 
+                'Drake Fang Talisman',
+                { class: 'Rogue', specname: 'Combat' },
                 undefined, 4, "hit bias"
             ),
             makePrio(
-                'Drake Fang Talisman', 
-                {class:'Rogue', specname:'Subtlety'}, 
+                'Drake Fang Talisman',
+                { class: 'Rogue', specname: 'Subtlety' },
                 undefined, 4, "hit bias"
             ),
             makePrio(
-                'Drake Fang Talisman', 
-                {class:'Warrior', specname:'Fury'}, 
+                'Drake Fang Talisman',
+                { class: 'Warrior', specname: 'Fury' },
                 undefined, 2, "hit bias"
             ),
             makePrio(
-                'Drake Fang Talisman', 
-                {class:'Druid', specname:'Feral (DPS)'}, 
+                'Drake Fang Talisman',
+                { class: 'Druid', specname: 'Feral (DPS)' },
                 undefined, 2, "hit bias"
             ),
 
             makePrio(
-                'Circle of Applied Force', 
-                {class:'Warrior', specname:'Fury'}, 
+                'Circle of Applied Force',
+                { class: 'Warrior', specname: 'Fury' },
                 undefined, 2, "str-to-ap bias"
             ),
             makePrio(
-                'Circle of Applied Force', 
-                {class:'Druid', specname:'Feral (DPS)'}, 
-                undefined, 2, "str-to-ap bias"
+                'Circle of Applied Force',
+                { class: 'Druid', specname: 'Feral (DPS)' },
+                undefined, 3, "str-to-ap bias + agi-to-ap bias"
             ),
 
             makePrio(
-                'Empowered Leggings', 
-                {class:'Paladin', specname:'Holy'}, 
+                'Empowered Leggings',
+                { class: 'Paladin', specname: 'Holy' },
                 undefined, 2, "crit bias"
             ),
             makePrio(
-                'Empowered Leggings', 
-                {class:'Druid', specname:'Restoration'}, 
+                'Empowered Leggings',
+                { class: 'Druid', specname: 'Restoration' },
                 undefined, 2, "crit bias"
             ),
 
             makePrio(
-                'Boots of the Shadow Flame', 
-                {class:'Rogue', specname:'Assassination'}, 
+                'Boots of the Shadow Flame',
+                { class: 'Rogue', specname: 'Assassination' },
                 undefined, 2, "hit bias"
             ),
             makePrio(
-                'Boots of the Shadow Flame', 
-                {class:'Rogue', specname:'Combat'}, 
+                'Boots of the Shadow Flame',
+                { class: 'Rogue', specname: 'Combat' },
                 undefined, 2, "hit bias"
             ),
             makePrio(
-                'Boots of the Shadow Flame', 
-                {class:'Rogue', specname:'Subtlety'}, 
+                'Boots of the Shadow Flame',
+                { class: 'Rogue', specname: 'Subtlety' },
                 undefined, 2, "hit bias"
             ),
             makePrio(
-                'Boots of the Shadow Flame', 
-                {class:'Druid', specname:'Feral (DPS)'}, 
+                'Boots of the Shadow Flame',
+                { class: 'Druid', specname: 'Feral (DPS)' },
                 undefined, 2, "hit bias"
             ),
 
             makePrio(
-                'Neltharion\'s Tear', 
-                {class:'Warlock', specname:'Demonology'}, 
+                'Neltharion\'s Tear',
+                { class: 'Warlock', specname: 'Demonology' },
                 undefined, 4, "hit bias"
             ),
             makePrio(
-                'Neltharion\'s Tear', 
-                {class:'Warlock', specname:'Affliction'}, 
+                'Neltharion\'s Tear',
+                { class: 'Warlock', specname: 'Affliction' },
                 undefined, 4, "hit bias"
             ),
             makePrio(
-                'Neltharion\'s Tear', 
-                {class:'Warlock', specname:'Destruction'}, 
+                'Neltharion\'s Tear',
+                { class: 'Warlock', specname: 'Destruction' },
                 undefined, 4, "hit bias"
             ),
             makePrio(
-                'Neltharion\'s Tear', 
-                {class:'Mage', specname:'Arcane'}, 
+                'Neltharion\'s Tear',
+                { class: 'Mage', specname: 'Arcane' },
                 undefined, 2, "hit bias"
             ),
             makePrio(
-                'Neltharion\'s Tear', 
-                {class:'Mage', specname:'Frost'}, 
+                'Neltharion\'s Tear',
+                { class: 'Mage', specname: 'Frost' },
                 undefined, 2, "hit bias"
             ),
             makePrio(
-                'Neltharion\'s Tear', 
-                {class:'Mage', specname:'Fire'}, 
+                'Neltharion\'s Tear',
+                { class: 'Mage', specname: 'Fire' },
                 undefined, 2, "hit bias"
             ),
 
             makePrio(
-                'Cloak of Draconic Might', 
-                {class:'Warrior', specname:'Fury'}, 
+                'Cloak of Draconic Might',
+                { class: 'Warrior', specname: 'Fury' },
                 undefined, 2, "str-to-ap bias"
             ),
             makePrio(
-                'Cloak of Draconic Might', 
-                {class:'Druid', specname:'Feral (DPS)'}, 
-                undefined, 2, "str-to-ap bias"
+                'Cloak of Draconic Might',
+                { class: 'Druid', specname: 'Feral (DPS)' },
+                undefined, 1, "str-to-ap bias"
             ),
-        ])
-
-
-        const user = Object.values(users)[0]
-        adminClient.managePriorities.setPriority(T1[0], {
-            race: user.character.race,
-            specid: user.character.specid,
-            modifier: 1,
-            description:'AAA'
-        }).then(() => {
-            adminClient.managePriorities.setPriority(T1[0], {
-                race: user.character.race,
-                specid: undefined,
-                modifier: 2,
-                description:'BBB'
-            }).then(()=>{
-                adminClient.managePriorities.setPriority(T1[0], {
-                    race: undefined,
-                    specid: user.character.specid,
-                    modifier: 3,
-                    description:'CCC'
-                }).then(()=>{
-                    client.ItemManager.calculatePriorities(T1[0], user.character).then(sum => {
-                        if(sum === 6)
-                            done()
-                    })
-                })
+        ]).then(() => {
+            const user = Object.values(users)[0]
+            client.ItemManager.calculatePriorities("Maladath, Runed Blade of the Black Flight", user.character).then(sum => {
+                if (sum === 3)
+                    done()
+                else
+                    console.log("Expected prio on maladath to be 4, but was:", sum, user.character);
             })
+
         })
     })
 
-    it('buy token', (done)=>{
-        Promise.all(Object.values(users).map(async (user) =>{
-            const itemname = T1[0]//T1[Math.floor(T1.length*Math.random())]
+    it('buy token', (done) => {
+        Promise.all(Object.values(users).map(async (user) => {
+            const itemname = "Maladath, Runed Blade of the Black Flight" //T1[Math.floor(T1.length*Math.random())]
             const modifier = await client.ItemManager.calculatePriorities(itemname, user.character)
 
             const token = await client.ItemManager.buyToken(user.auth.token.value, user.character.charactername, itemname, user.signup!)
             users[user.account.username].item = itemname
-            
-            if(!token) return false
-            return modifier+1 === token.level
+
+            if (!token) return false
+            return modifier + 1 === token.level
         })).then(success => {
-            if(success.reduce((prev, curr)=>prev&&curr, true)) done()
+            if (success.reduce((prev, curr) => prev && curr, true)) done()
         })
     })
 
-    it('not buy token without currency', (done)=>{
+    it('not buy token without currency', (done) => {
         const user = Object.values(users)[0]
-        const itemname = T1[0]
+        const itemname = "Maladath, Runed Blade of the Black Flight"
         client.ItemManager.buyToken(user.auth.token.value, user.character.charactername, itemname, user.signup!).then(token => {
-            if(!token) 
+            if (!token)
                 done()
             else {
                 console.log("Unexpected token", token);
         })
     })
 
-    it('upgrade token', (done)=>{
+    it('upgrade token', (done) => {
         const user = Object.values(users)[0]
-        const itemname = T1[0]
-
-        adminClient.softreserveCurrency.incrementCurrency(user.account, raids[0].tier, 2).then(async ()=>{
-            const item = await client.ItemManager.getItem(itemname)
+        const itemname = "Maladath, Runed Blade of the Black Flight"
+        client.ItemManager.getItem(itemname).then(async item => {
+            await adminClient.softreserveCurrency.incrementCurrency(user.account, item.tier, 2)
             const before = await client.ItemManager.getToken(user.character, item)
-            
-            if(!before || before.level !== 7) {
-                console.log("expected level to be 7", before);
+
+            if (!before || before.level !== 4) {
+                console.log("expected level to be 4", before ? before.level : '?');
                 return
             }
-            
+
             await client.ItemManager.buyToken(user.auth.token.value, user.character.charactername, itemname, user.signup!)
             const after = await client.ItemManager.buyToken(user.auth.token.value, user.character.charactername, itemname, user.signup!)
 
-            if(!after || after.level !== 9) {
-                console.log("expected level to be 9", after);
+            if (!after || after.level !== 6) {
+                console.log("expected level after to be 6", after ? after.level : '?');
                 return
             }
             done()
 
     it('should buy more tokens', (done) => {
         Promise.all(Object.values(users).map(async (user) => {
-            await adminClient.softreserveCurrency.incrementCurrency(user.account,raids[0].tier, 1)
+            await adminClient.softreserveCurrency.incrementCurrency(user.account, raids[0].tier, 1)
             return await client.ItemManager
-            .buyToken(
-                user.auth.token.value, 
-                user.character.charactername, 
-                T1[Math.floor(T1.length*Math.random())],
-                user.signup!
-            )
+                .buyToken(
+                    user.auth.token.value,
+                    user.character.charactername,
+                    T2[Math.floor(T2.length * Math.random())],
+                    user.signup!
+                )
         })).then(_ => {
             done()
         })
     })
 
     it('start raid', (done) => {
-        client.RaidManager.getRaids().then((r)=>{
+        client.RaidManager.getRaids().then((r) => {
             adminClient.manageRaid.startRaid(raids[0]).then(async data => {
                 const dbRaids = await client.RaidManager.getRaids()
-                if(dbRaids.length === 0){
+                if (dbRaids.length === 0) {
                     await client.UserManager.getUser(testAccounts[0].name).then(dbUser => {
-                        if(dbUser && dbUser.MC === 1){
+                        if (dbUser && dbUser.BWL === 1) {
                             adminClient.signup.getSignups(raids[0]).then(signups => {
-                                if(signups.length === 0){
+                                if (signups.length === 0) {
                                     done()
-                                }else{
+                                } else {
                                     console.log(signups);
                                 }
                             })
                         }
-                        else{
+                        else {
                             console.log("Bad user currency", dbUser);
                         }
                     })
     it('reset system', (done) => {
         adminClient.reset.wipeCurrencyAndItems().then(() => {
             client.UserManager.getUser(testAccounts[0].name).then(user => {
-                if(user && user.MC === 1){
-                    client.ItemManager.getTokens(users[testAccounts[0].name.toLowerCase()].character, ['MC']).then(tokens => {
-                        if(tokens!.length === 0){
+                if (user && user.MC === 1) {
+                    client.ItemManager.getTokens(users[testAccounts[0].name.toLowerCase()].character, ['BWL']).then(tokens => {
+                        if (tokens!.length === 0) {
                             done()
-                        }else{
+                        } else {
                             console.log(tokens);
                         }
                     })
-                }else{
+                } else {
                     console.log(user)
                 }
             })
         })
     })
 
-    it('implements loot system correctly', (done)=>{
+    it('implements loot system correctly', (done) => {
         const ONE_WEEK = 4800000000
-        
-        const Raid = (week:number, tier:string) => {
-                return <Raid>{
-                description: tier+" Test raid 1",
+
+        const Raid = (week: number, tier: string) => {
+            return <Raid>{
+                description: tier + " Test raid 1",
                 title: tier,
-                start: (week*ONE_WEEK + Date.now()).toString(),
+                start: (week * ONE_WEEK + Date.now()).toString(),
                 tier: tier
             }
         }
         const user = Object.values(users)[0]
         const createRaid = adminClient.manageRaid.createRaid
-        const sign = async (raid:Raid, late = false) => await adminClient.signup.sign(user.auth.token.value, user.character, raid, late)
+        const sign = async (raid: Raid, late = false) => await adminClient.signup.sign(user.auth.token.value, user.character, raid, late)
         const buyToken = async (signup: Signup, itemname: string) => await client.ItemManager.buyToken(user.auth.token.value, user.character.charactername, itemname, signup)
+        const getCurrency = async (tier: Tiers) => {
+            const dbUser = await client.UserManager.getUser(user.account.username)
+            return dbUser[tier]
+        }
 
-        createRaid(Raid(0, 'MC')).then(async (MC0:Raid) => {
-            const T1_0 = await client.ItemManager.getItem(T1[0])
+        createRaid(Raid(0, 'BWL')).then(async (BWL0: Raid) => {
+            const T2_0 = await client.ItemManager.getItem(T2[0])
             //const BWL0 = await createRaid(Raid(0, 'BWL'))
-            const signupMC0 = await sign(MC0)
-            let token = await buyToken(signupMC0, T1[0])
-            if(!token){
-                console.log(MC0, signupMC0)
-                done("No token created")
+            const signupBWL0 = await sign(BWL0)
+            let BWL = await getCurrency(BWL0.tier)
+            let token = await buyToken(signupBWL0, T2[0])
+            const BWLAfter = await getCurrency(BWL0.tier)
+
+            if (!token
+                || BWL - BWLAfter != 1) {
+                console.log("Bad Token status", BWL0, signupBWL0, BWL, BWLAfter)
+                done(new Error("Bad Token status 0"))
                 return
             }
 
-            let reserves = await client.ItemManager.getTokens(user.character, [MC0.tier], true)
-            let streaks = await client.ItemManager.getTokens(user.character, [MC0.tier], false)
-            if(reserves!.length != 1 
-            || streaks!.length != 0
-            || reserves![0].itemname !== T1_0.itemname
-            || reserves![0].level !== 7){
-                console.log(reserves, streaks);
-                done("Bad token status")
+            let reserves = await client.ItemManager.getTokens(user.character, [BWL0.tier], true)
+            let streaks = await client.ItemManager.getTokens(user.character, [BWL0.tier], false)
+            if (reserves!.length != 1
+                || streaks!.length != 0
+                || reserves![0].itemname !== T2_0.itemname
+                || reserves![0].level !== 1) {
+                console.log("Bad Token status 1", reserves, streaks);
+                done(new Error("Bad Token status"))
+                return
+            }
+            await adminClient.manageRaid.startRaid(BWL0)
+            reserves = await client.ItemManager.getTokens(user.character, [BWL0.tier], true)
+            streaks = await client.ItemManager.getTokens(user.character, [BWL0.tier], false)
+            if (reserves!.length != 0
+                || streaks!.length != 1
+                || streaks![0].itemname !== T2[0]
+                || streaks![0].level !== 1) {
+                console.log("Bad Token status", reserves, streaks);
+                done(new Error("Bad Token status 2"))
                 return
             }
-            await adminClient.manageRaid.startRaid(MC0)
-            reserves = await client.ItemManager.getTokens(user.character, [MC0.tier], true)
-            streaks = await client.ItemManager.getTokens(user.character, [MC0.tier], false)
-            if(reserves!.length != 0 
-            || streaks!.length != 1
-            || streaks![0].itemname !== T1[0]
-            || streaks![0].level !== 7){
-                console.log(reserves, streaks);
-                done("Bad token status")
+
+            const BWL1 = await createRaid(Raid(1, 'BWL'))
+
+            let signupBWL1 = await sign(BWL1)
+            BWL = await getCurrency(BWL1.tier)
+            await adminClient.manageRaid.adminUnsign(user.character, BWL1)
+            let afterUnsign = await getCurrency(BWL1.tier)
+            if (BWL !== afterUnsign) {
+                console.log("Expected currency to be equal", BWL, afterUnsign)
+                done(new Error("Expected currency to be equal"))
                 return
             }
 
-            const MC1 = await createRaid(Raid(1, 'MC'))
-            const signupMC1 = await sign(MC1)
-            token = await buyToken(signupMC1, T1[1])
-            reserves = await client.ItemManager.getTokens(user.character, [MC1.tier], true)
-            streaks = await client.ItemManager.getTokens(user.character, [MC1.tier], false)
-            if(reserves!.length != 1 
-            || streaks!.length != 0
-            || reserves![0].itemname !== T1[1]
-            || reserves![0].level !== 1){
-                console.log(reserves, streaks);
-                done("Bad token status")
+            signupBWL1 = await sign(BWL1)
+            BWL = await getCurrency(BWL1.tier)
+            await buyToken(signupBWL1, T2[1])
+            await adminClient.manageRaid.adminUnsign(user.character, BWL1)
+            afterUnsign = await getCurrency(BWL1.tier)
+            if (BWL !== afterUnsign) {
+                console.log("Expected currency to be equal", BWL, afterUnsign)
+                done(new Error("Expected currency to be equal"))
+                return
+            }
+
+            signupBWL1 = await sign(BWL1)
+            await buyToken(signupBWL1, T2[1])
+            reserves = await client.ItemManager.getTokens(user.character, [BWL1.tier], true)
+            streaks = await client.ItemManager.getTokens(user.character, [BWL1.tier], false)
+            if (reserves!.length != 1
+                || streaks!.length != 0
+                || reserves![0].itemname !== T2[1]
+                || reserves![0].level !== 1) {
+                console.log("Bad Token status", reserves, streaks);
+                done(new Error("Bad Token status 3"))
+                return
+            }
+
+            BWL = await getCurrency(BWL1.tier)
+            const data = await adminClient.manageRaid.startRaid(BWL1)
+
+            const afterStart = await getCurrency(BWL1.tier)
+            if (BWL != 0 || afterStart != 1) {
+                console.log("Wrong currency values", BWL, afterStart)
+                done(new Error("Wrong currency values"))
                 return
             }
 
 
         }).catch(e => {
             console.log(e);
-            
+
             done(e)
         })
     })