working buytoken (untested)

src/backend/Components/Item/ItemManager.ts

         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')
+                .transacting(tx)
                 .where({
                     characterid: character.id,
                     itemname: item.itemname
             //getLogger('ItemManager').debug('delete streaks')
             await Promise.all(streaks.map(async s => await this.admin
                 .knex(item.tier+'tokens')
+                .transacting(tx)
                 .where({
                     itemname: s.itemname,
                     characterid: character.id,
                 })
                 .del()
             ))
-            
-            if(myStreak)
+
+            if(myStreak){
+                await tx.commit()
                 return await this.getToken(character, item)
+            }
         }
 
         const matchingReserve = activeTokens.find(token => token.itemname === itemname)
         if(matchingReserve){
-            getLogger('ItemManager').debug('upgrade reserve')
+            //getLogger('ItemManager').debug('upgrade reserve')
             await this.admin
             .knex(item.tier+'tokens')
+            .transacting(tx)
             .increment('level')
             .where({
                 signupid: signup.id,
                 itemname: item.itemname
             })
         }else{
-            getLogger('ItemManager').debug('new reserve')
+            //getLogger('ItemManager').debug('new reserve')
             await this.admin
             .knex(item.tier+'tokens')
+            .transacting(tx)
             .insert({
                 characterid: character.id,
                 itemname: item.itemname,
                 signupid: signup.id
             })
         }
+        await tx.commit()
         return await this.getToken(character, item)
     }
 

src/backend/Components/Raid/Interface.ts

 
 export class IRaidManager{
     getRaids: () => Promise<Raid[]>
-    createRaid: (raid:Raid) => Promise<any>
-    addSignup: (signup: Signup) => Promise<any>
+    createRaid: (raid:Raid) => Promise<Raid>
+    addSignup: (signup: Signup) => Promise<Signup>
     removeSignup: (signup: Signup) => Promise<any>    
     getSignups: (raid:Raid) => Promise<(Signup & Character & Spec & User)[]>
     sign: (userToken: string, character:Character, raid:Raid, late:boolean) => Promise<any>

src/backend/Components/Raid/RaidManager.ts

                     table.string('description').notNullable()
                     table.string('title').notNullable()
                     table.integer('size').defaultTo(40)
-                    table.enu('tier', _Tiers).defaultTo(null as any)
+                    table.string('tier').defaultTo('null')
                 }
             },{
                 name: 'archive',
         ]
     }
 
-    createRaid = async (raid:Raid) => await this.admin
-    .knex('raids')
-    .insert(raid)
-    
-    addSignup = async (signup: Signup) => await this.admin
-    .knex('signups')
-    .insert(signup)
-    
+    createRaid = async (raid:Raid) : Promise<Raid>=> {
+        const ids:number[] = await this.admin
+        .knex('raids')
+        .insert(raid)
+
+        return await this.admin.knex('raids').where({id: ids[0]}).first()
+    }
+
+    addSignup = async (signup: Signup) => {
+
+        const ids:number[] = await this.admin
+        .knex('signups')
+        .insert(signup)
+        return await this.admin.knex('signups').where({id: ids[0]}).first()
+
+    }
+
     removeSignup = async (signup: Signup) => await this.admin
     .knex('signups')
     .where({

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

         <br/><br />
         <span *ngFor="let token of tokens">
             [ {{token.level}} ]
-            <wowhead [item]="token"></wowhead><br />
+            <wowhead [item]="token"></wowhead>
         </span>
     </nb-card-body>
 </nb-card>

src/frontend/src/app/frontcraft/pages/raids/createraid.compontent.ts

   loadNext(cardData) {
   }
 
+  onTierSelect(){
+    
+  }
+
   onTemplateSelect(){
     const templateDate = new Date(this.template.start)
     this.title = this.template.title

test/backendTest.ts

 
 type protoAccount<C extends Class = Class> = {
     name : string,
+    pwHash?: string
     rank : Rank,
     race: Race,
     class: C,
         adminClient.manageRaid.createRaid(insertRaid).then(() => {
             client.RaidManager.getRaids().then((r)=>{
                 if(r[0].title === insertRaid.title 
-                && r[0].description === insertRaid.description){
+                && r[0].description === insertRaid.description
+                && r[0].tier === "MC"){
                     raids.push(r[0])
                     done()
                 }
             })
         })
     })
+
+    it('implements loot system correctly', (done)=>{
+        const ONE_WEEK = 4800000000
+        
+        const Raid = (week:number, tier:string) => {
+                return <Raid>{
+                description: tier+" Test raid 1",
+                title: tier,
+                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 buyToken = async (signup: Signup, itemname: string) => await client.ItemManager.buyToken(user.auth.token.value, user.character.charactername, itemname, signup)
+
+        createRaid(Raid(0, 'MC')).then(async (MC0:Raid) => {
+            const T1_0 = await client.ItemManager.getItem(T1[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")
+                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")
+                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")
+                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")
+                return
+            }
+
+            done()
+
+        }).catch(e => {
+            console.log(e);
+            
+            done(e)
+        })
+    })
 })