pretty up

src/backend/Admin/Admin.ts

                         connection: {
                             filename: Path.join(__dirname, "data/frontworkAdmin.sqlite")
                         },
-                        useNullAsDefault: true
+                        useNullAsDefault: true,
                     }
                 }   
             }

src/backend/Components/Item/Interface.ts

     setPriority: (itemname:string, priority: any) => Promise<void>
     calculatePriorities: (itemname: string, character:Character) => Promise<number>
     deletePriority: (priority:SRPriority) => Promise<void>
-    getTokens: (character:Character) => Promise<SRToken[]>
-    getToken: (character:Character, item:Item) => Promise<(SRToken & Character & Item) | void>
+    getTokens: (character:Character, valid?:boolean) => Promise<SRToken[]>
+    getToken: (character:Character, item:Item, valid?:boolean) => Promise<(SRToken & Character & Item) | void>
     getAllPriorities: () => Promise<(SRPriority & Spec & Item)[]>
     wipeCurrencyAndItems: () => Promise<void>
 }

src/backend/Components/Item/ItemManager.ts

             if(matchingtoken){
                 //update signupid and increment level
                 
-                console.log("delete shadow tokens");
+                
 
                 await this.admin
                 .knex('tokens')
+                .where({
+                    characterid: character.id,
+                    itemname: item.itemname
+                })
                 .update({
                     signupid: signup.id,
                     level: matchingtoken.level+1
                 })
+                
+                await this.admin
+                .knex('tokens')
                 .where({
                     characterid: character.id,
-                    itemname: item.itemname
-                })
+                    itemname: item.itemname,
+                    signupid: null
+                }).del()
+                
                 return await this.getToken(character, item)
             }
         }
         }).reduce((prev, curr) => prev+curr, 0)
     }
 
-    getToken = async (character:Character, item:Item): Promise<(SRToken & Character & Item) | void>=> {
+    getToken = async (character:Character, item:Item,valid=true): Promise<(SRToken & Character & Item) | void>=> {
         return await this.admin
         .knex('tokens as t')
         .select('*')
             characterid: character.id,
             "i.itemname": item.itemname
         })
+        .andWhere(function(){
+            if(valid){
+                this.whereNotNull('t.signupid')
+            }else{
+                this.whereNull('t.signupid')
+            }
+        })
         .first()
     }
 

src/backend/Components/Raid/Interface.ts

     getPastRaids: (limit: number) => Promise<RaidData[]>
     getArchiveRaid: (id:number) => Promise<RaidData>
     startRaid: (raid:Raid) => Promise<RaidData>
+    adminUnsign: (character:Character, raid:Raid) => Promise<any>
 }

src/backend/Components/Raid/RPCInterface.ts

         archiveRaid: IRaidManager['archiveRaid']
         setBenched: IRaidManager['setBenched']
         startRaid: IRaidManager['startRaid']
+        adminUnsign: IRaidManager['adminUnsign']
     }
     signup: {
         getSignups: IRaidManager['getSignups']

src/backend/Components/Raid/RaidManager.ts

 import { IUserManager } from "../User/Interface";
 import { ICharacterManager } from "../Character/Interface";
 import { _Tiers } from "../../Types/Items";
+import { IItemManager } from "../Item/Interface";
+import { ItemManager } from "../Item/ItemManager";
+import { SpecT } from "../../Types/PlayerSpecs";
 
 @Injectable(IRaidManager)
 export class RaidManager
     @Inject(ICharacterManager)
     private characterManager: ICharacterManager
 
+    @Inject(ItemManager)
+    private itemManager: IItemManager
+
     exportRPCs = () => [
         this.getRaids,
         this.getRaidData,
                 this.removeSignup,
                 this.archiveRaid,
                 this.setBenched,
-                this.startRaid
+                this.startRaid,
+                this.adminUnsign
             ]
         },{
             name: 'signup' as 'signup',
 
     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)
         })       
 
         await Promise.all(
-            Object.values(raidData.participants).flat().flatMap((signup) =>  this.admin
+            Object.values(raidData.participants).flat().flatMap((signup) => this.admin
                 .knex('tokens')
+                .transacting(tx)
                 .where({
                     characterid: signup.characterid,
                     signupid: null
         ))
 
         await this.admin.knex('raids')
+        .transacting(tx)
         .where('id', '=', raid.id)
         .del()
+        await tx.commit()
+
     
         const row = await this.admin.knex('archive')
         .select('*')
             id:raidData.id,
         })
         .first()
-
         return JSON.parse(row.raiddata)
     }
 
     }
 
     getRaidData = async (raid:Raid) : Promise<RaidData> => {
-        const ret = {
+        const raiddata = {
             participants:{
                 Druid: <(Signup&Character&Spec)[]>[],
                 Hunter: <(Signup&Character&Spec)[]>[],
                 late: <(Signup&Character&Spec)[]>[],
                 bench: <(Signup&Character&Spec)[]>[],
             },
-            tokens:{}
+            tokens:{},
+            healers:<(Signup&Character&Spec)[]>[],
+            tanks:<(Signup&Character&Spec)[]>[]
         }
+        const tx = await this.admin.knex.transaction()
 
         const subQuery = this.admin
         .knex('signups')
         })
         .as('signupcount')
 
+
         const raidInDb: Raid = await this.admin.knex('raids')
         .select('*', subQuery)
+        .transacting(tx)
         .where('id','=',raid.id)
         .first()
 
         const characterData: (Signup & Character & Spec)[] = await this.admin
         .knex('signups as s')
-        .select('s.id as id', 'charactername', 'class', 'specname', 'race', 'userid', 'benched', 'late', 'raidid', 'characterid')
+        .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')
         
         characterData.forEach(data => {
             if(data.benched){
-                ret.participants.bench.push(data)
+                raiddata.participants.bench.push(data)
                 return
             }
             if(data.late){
-                ret.participants.late.push(data)
+                raiddata.participants.late.push(data)
                 return
             }
-            ret.participants[data.class].push(data)
+            raiddata.participants[data.class].push(data)
         })
 
         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')
         .where('r.id','=',raid.id)
         .join('tokens as t', 't.characterid','=','c.id')
         .join('items as i', 'i.itemname','=','t.itemname')
 
+        await tx.commit()
+
         tokenData.forEach(data => {
-            if(!ret.tokens[data.itemname])
-                ret.tokens[data.itemname] = []
-            ret.tokens[data.itemname].push(data)
+            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)"))
+        )
+        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"))
+        )
+
         return {
             ...raidInDb,
-            ...ret
+            ...raiddata
         }
     }
     
         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!,
         if(!exists){
             await this.admin
             .knex('signups')
+            .transacting(tx)
             .insert({
                 raidid: raid.id!,
                 characterid: character.id!,
-                late: late
+                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
+                late: late,
+                benched: false,
             })
         }
+        await tx.commit()
 
         return await this.admin
         .knex('signups')
             throw new Error("Bad Usertoken")
         }
 
+        return await this.adminUnsign(character, 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()
+
+        const tokens = await this.admin.knex('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, 1)       
+                const prio = await this.itemManager.calculatePriorities(token.itemname, character)
+                if(token.level <= prio+1){
+                    await this.admin.knex('tokens')
+                    .where({
+                        characterid: character.id,
+                        itemname: token.itemname
+                    }).del()
+                }else{
+                    await this.admin.knex('tokens')
+                    .where({
+                        characterid: character.id,
+                        itemname: token.itemname
+                    }).update({
+                        signupid: null,
+                        level: token.level-1
+                    })
+                }
+            })
+        )
+
         await this.admin.knex('signups')
         .where({
             raidid: raid.id!,

src/backend/Types/Types.ts

     tokens: {
         [itemname in string]: (Character & SRToken & Item)[]
     }
+    tanks: (Signup & Character & Spec)[] 
+    healers: (Signup & Character & Spec)[] 
 }
 
 export type SRToken = {

src/frontend/src/app/@theme/components/header/header.component.ts

 
     this.api.connectShoutbox((msg) => {
       this.chatlog.push(msg)
-      if(msg.message != this.lastmessage)
+      msg['reply']=false
+
+      if(msg.message != this.lastmessage){
         this.newmessage = true
+        msg['reply']=true
+      }
       if(this.chatwindow) this.chatwindow.messages.push(msg)
     }).then(sendMsg => {
       this.sendMessage = (msg) => {

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

     </nb-card-header>
 
     <nb-card-body>
+        <img style="width:20px; height:20px" [src]="'../../../../assets/images/'+char.race.toLowerCase()+'_xs.gif'" />
         {{char.race}}<br />
+        <img style="width:20px; height:20px" [src]="'../../../../assets/images/'+char.class.toLowerCase()+'.png'" />
         {{char.specname}} {{char.class}}<br />
         <span *ngIf="link === 'owner'">
             Owned by <a [routerLink]="'/frontcraft/user/'+char.username"> {{char.username}} ({{char.rank}})</a>

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

     @Input() name?: string
     @Input() link?: "owner" | "character" = 'owner'
 
-    char : (Character & User & Spec) = {} as any
+    char : (Character & User & Spec) = {
+      race: 'Human',
+      class: 'Warrior'
+    } as any
     color : string
     tokens
 

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

                         </a>
                     </td>
                     <td>
+                        <img style="width:20px; height:20px" [src]="'../../../../assets/images/'+character.race.toLowerCase()+'_xs.gif'" />
                         {{character.race}}
                     </td>
                     <td>
                         {{character.specname}}
                     </td>
                     <td>
+                        <img style="width:20px; height:20px" [src]="'../../../../assets/images/'+character.class.toLowerCase()+'.png'" />
                         {{character.class}}
                     </td>
                 </tr>

src/frontend/src/app/frontcraft/pages/pages-layout.component.ts

     icon: 'people',
     title: 'Characters',
     link: '/frontcraft/characters',
-  },{
-    icon: 'shopping-cart',
-    title: 'Token Shop',
-    link: '/frontcraft/shop',
   },{
     icon: 'book-open-outline',
     title: 'Loot Rules',

src/frontend/src/app/frontcraft/pages/pages-routing.module.ts

                 path: 'characters',
                 component: FrontcraftCharactersComponent,
             },
-            {
-                path: 'shop',
-                component: FrontcraftShopComponent
-            },
             {
                 path: 'rules',
                 component: FrontcraftRulesComponent

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

           Warlock: [],
           Warrior: [],
       },
-      tokens:{}
+      tokens:{},
+      tanks:[],
+      healers: []
     }
+    tokens = {}
+    displayedtokens = {}
+    search = ""
     
     constructor(
       private api: ApiService,
       const raidManager = this.api.get('RaidManager')
       const raiddata = await raidManager.getArchiveRaid(parseInt(param))
       this.raid = raiddata
+      this.tokens = raiddata.tokens;
 
-      Object.values(raiddata.participants).flat().forEach(p => {
+      [
+        ...raiddata.tanks, 
+        ...raiddata.healers, 
+        ...Object.values(raiddata.participants).flat()
+      ].forEach(p => {
         p['color'] = getClassColor(p.class)
       })
-      
-      const matchingSignup = Object.values(raiddata.participants).flat().find(char => char.userid === this.api.getCurrentUser()!.id!)
-      if(matchingSignup){
-        this.isSignedup = true
-        this.mySignup = matchingSignup
-        this.mySignup.status = matchingSignup['benched']?'Bench':matchingSignup['late']?'Late':'Attending'
-      }else{
-        this.isSignedup = false
-        this.mySignup = null
-      }
-    } 
+
+      this.changeSearch()
+    }
+
+    changeSearch = () => {
+      this.tokens = this.raid.tokens;
+      this.displayedtokens = this.raid.tokens;
+    }
 }

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

                             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)="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">
-                            unsign
-                        </button>                    
+                            <nb-icon icon="close"></nb-icon>unsign
+                        </button>               
                     </div>
                     <div *ngIf="!isSignedup">
                         <button
                             outline 
                             status="success" 
                             size="medium">
-                            signup
+                            <nb-icon icon="person-done-outline"></nb-icon> sign up
                         </button>                     
                     </div>
                 </div>
               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
+                                </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" 
                                         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>
                     </ng-container>
                 </div>
             </nb-tab>
-            <nb-tab tabTitle="Shop">
+            <nb-tab tabTitle="Shop" *ngIf="isSignedup">
                 <shop (onSelect)="itemSelect($event)"></shop>
             </nb-tab>
             <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 raid.tokens | keyvalue">
+                    <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">
                     size="medium">
                     start
                 </button>
-
-                <button
-                    (click)="archiveRaid(raid)"
-                    nbButton 
-                    outline 
-                    status="danger" 
-                    size="medium">
-                    archive
-                </button>
             </nb-tab>
         </nb-tabset>
     </nb-card-body>

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

 import { Component, OnInit } from '@angular/core';
 import { ActivatedRoute, Router } from '@angular/router';
 import { ApiService as ApiService } from '../../services/login-api';
-import { RaidData, Raid, Signup } from '../../../../../../backend/Types/Types';
+import { RaidData, Raid, Signup, Character, Spec, Item, SRToken } from '../../../../../../backend/Types/Types';
 import { NbWindowService, NbToastrService, NbDialogService } from '@nebular/theme';
 import { FrontcraftCharacerpickerComponent } from './characterpicker.component';
-import { getClassColor } from '../../../../../../backend/Types/PlayerSpecs';
+import { getClassColor, SpecT } from '../../../../../../backend/Types/PlayerSpecs';
 import { FrontcraftBuyTokenComponent } from '../shop/buytoken.component';
 
 @Component({
 
     canSignup = false
     isSignedup = false
+    islate = false
     manageRaid
-    mySignup
+    mySignup: (Signup & Character & Spec)
 
     raid: RaidData = <any>{
       participants:{
           Warlock: [],
           Warrior: [],
       },
+      tanks: [],
+      healers: [],
       tokens:{}
     }
-    
+    tokens = {}
+    displayedtokens = {}
+    search = ""
+
     constructor(
       private api: ApiService,
       private route: ActivatedRoute,
       const signupFeature = this.api.get('signup')
       if(!signupFeature) return
 
-      await signupFeature.unsign(this.api.getAuth().token.value, <any>{id: this.mySignup.characterid, userid: this.mySignup.userid}, this.raid)
+      await signupFeature.unsign(this.api.getAuth().token.value, {
+        ...this.mySignup,
+        id: this.mySignup.characterid, 
+      }, this.raid)
       this.toast.show('Success', 'Unsigned', { status: 'success' })
       this.refresh()
     }
 
+    setLate = async (value:boolean) => {
+      const auth = this.api.getAuth()
+      const signup = this.api.get('signup')
+      if(!signup) return
+
+      console.log("setlate");
+      
+
+      await signup.sign(auth.token.value, {
+        ...this.mySignup,
+        id: this.mySignup.characterid,
+      }, this.raid, value)
+      this.toast.show('Signup', 'Success', { status: 'success' })
+      this.refresh()
+    }
+
+    adminUnsign = async() => {
+      const manage =  this.api.get('manageRaid')
+      if(!manage) return
+      await manage.adminUnsign({
+        ...this.mySignup,
+        id: this.mySignup.characterid, 
+      }, this.raid)
+      this.refresh()
+    }
+
     refresh = async () => {
       const param = this.route.snapshot.paramMap.get('id');
 
       const raiddata = await raidManager.getRaidData(<any>{
         id: param
       })
+        
       this.raid = raiddata
+      this.tokens = raiddata.tokens;
 
-      Object.values(raiddata.participants).flat().forEach(p => {
+      [...raiddata.tanks, ...raiddata.healers, ...Object.values(raiddata.participants).flat()].forEach(p => {
         p['color'] = getClassColor(p.class)
       })
+
       const user = this.api.getCurrentUser()
       const matchingSignup = Object.values(raiddata.participants).flat().find(char => user && char.userid === user.id!)
       if(matchingSignup){       
-
         this.isSignedup = true
         this.mySignup = matchingSignup
-        this.mySignup.status = matchingSignup['benched']?'Bench':matchingSignup['late']?'Late':'Attending'
+        this.mySignup['status'] = matchingSignup['benched']?'Bench':matchingSignup['late']?'Late':'Attending'
       }else{
         this.isSignedup = false
         this.mySignup = null
       }
+      this.changeSearch()
+    }
+
+    changeSearch(){
+      if(!this.search || this.search == ""){
+        this.displayedtokens = this.tokens
+      }else{
+        this.displayedtokens = {}
+        Object.entries(this.tokens).forEach((e: [string, (Character & SRToken & Item)[]]) => {
+          const filteredTokens = e[1].filter(item => {
+            return item.itemname.toLocaleLowerCase().includes(this.search.toLocaleLowerCase())
+          })
+          if(filteredTokens.length > 0)
+            this.displayedtokens[e[0]] = filteredTokens 
+        })
+      }
     }
 
     setBench(signup:Signup){

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

                             <ng-template #templateRef>
                                 <span style="color:white">{{rule.description}}</span>
                             </ng-template>
-                            +{{rule.modifier}} {{rule.race}} <span [ngStyle]="{'color':rule.color}">{{rule.specname}} {{rule.class}}</span> <br />
+                            <span *ngIf="rule.modifier>0">+</span>{{rule.modifier}} {{rule.race}} <span [ngStyle]="{'color':rule.color}">{{rule.specname}} {{rule.class}}</span> <br />
                         </span>
                     </nb-list-item>
                 </nb-list>

src/frontend/src/app/frontcraft/pages/shop/buytoken.component.ts

         .then(chars => {
             chars.forEach(char => {
                 char['color'] = getClassColor(char.class)
-                this.api.get('ItemManager').getToken(char, this.item).then(token => {
-                  if(token) this.ownedtokens.push(token)
-                  else{
-                    this.api.get('ItemManager').calculatePriorities(this.item.itemname, char).then(modifier => {
-                      this.modifier[char.charactername] = modifier
-                    })
-                  }
+                this.api.get('ItemManager').getToken(char, this.item, false).then(token => {
+                    if(token) this.ownedtokens.push(token)
+                    else{
+                        this.api.get('ItemManager').getToken(char, this.item, true).then(tokken => {
+                            if(tokken) this.ownedtokens.push(tokken)
+                            else{
+                                this.api.get('ItemManager').calculatePriorities(this.item.itemname, char).then(modifier => {
+                                    this.modifier[char.charactername] = modifier
+                                })
+                            }
+                        })
+                    }
                 })
             })
             this.characters = chars
     }
   
     buyToken = async (charactername:string) => {
-
-    const src = this.api.get('ItemManager')
-    const token = await src.buyToken(this.api.getAuth().token.value, charactername, this.item.itemname, this.signup)
-  
-    if(token){
-      this.toastr.show(token.characterid+' now has a token for '+token.itemname+' of level '+token.level, 'Yay', {status: 'success'})
-    }else{
-      this.toastr.show('Error (something went wrong)', 'Oh no', {status: 'danger'})
-    }
-    this.dialogRef.close()
+        const src = this.api.get('ItemManager')
+        const token = await src.buyToken(this.api.getAuth().token.value, charactername, this.item.itemname, this.signup)
+    
+        if(token){
+        this.toastr.show(token.characterid+' now has a token for '+token.itemname+' of level '+token.level, 'Yay', {status: 'success'})
+        }else{
+        this.toastr.show('Error (something went wrong)', 'Oh no', {status: 'danger'})
+        }
+        this.dialogRef.close()
     }
   }

test/backendTest.ts

         spec: 'Fury',
         rank: 'Classleader'
     },{
-        name: 'Teenieweenie',
+        name: 'Teeniweeni',
         class: 'Warlock',
         race: 'Gnome',
         spec: 'Demonology',
                 undefined, 1, "hit bias"
             ),
 
+            makePrio(
+                '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)"
+            ),
+            makePrio(
+                'Maladath, Runed Blade of the Black Flight', 
+                {class:'Rogue', specname:'Combat'}, 
+                undefined, 2, "...Rogues (weapon skill bias)"
+            ),
+            makePrio(
+                'Maladath, Runed Blade of the Black Flight', 
+                {class:'Rogue', specname:'Assassination'}, 
+                undefined, 2, "...Rogues (weapon skill bias)"
+            ),
             makePrio(
                 'Maladath, Runed Blade of the Black Flight', 
                 {class:'Warrior', specname:'Fury'}, 
-                'Human', 2, "weapon skill bias"
+                'Human', 4, "+2 Fury Warrior (weapon skill bias), +2 to offset (1)"
             ),
 
             makePrio(
                         }
                         else{
                             console.log("Bad user currency", dbUser);
-                            
                         }
                     })
                 }