suivi-loot-wow-api/dao/roster.dao.js

import sqlite3 from 'sqlite3'
import ErrorType from '../error/types.error.js'
import serverConfig from '../configuration/server.config.js'

sqlite3.verbose()

const tableName = 'Roster'
const historyTableName = 'Histories'

class Roster {
  constructor(options = {}) {
    if (!options.name || !options.classe || !options.role) {
      throw new Error('Member has to have a name, a class and a role')
    }
    this.name = options.name
    this.classe = options.classe
    this.role = options.role
  }

  static findAll() {
    return new Promise((resolve, reject) => {
      const db = openDB()
      db.serialize(() => {
        db.all(`SELECT * FROM ${tableName} order by name asc`, (err, rosters) => {
          if (err) reject(new Error(ErrorType.TECHNICAL_UNKNOWN))
          else {
            const array = [];
            for (const roster of rosters) {
              array.push(createRosterFromDB(roster))
            }
            resolve(array);
          }
        })
        closeDB(db)
      })
    })
  }

  static getBisData(raidDate) {
    return new Promise((resolve, reject) => {
      const db = openDB()
      db.serialize(() => {
        const query = `
SELECT 
  ${tableName}.name,
  ${tableName}.classe,
  '[' || GROUP_CONCAT(
    '{' || 
      '"equipLoc": "' || IFNULL(${historyTableName}.equipLoc, '') || '", ' ||
      '"response": "' || IFNULL(${historyTableName}.response, '') || '", ' ||
      '"instance": "' || IFNULL(${historyTableName}.instance, '') || '", ' ||
      '"itemName": "' || IFNULL(${historyTableName}.itemName, '') || '"' ||
    '}'
  ) || ']' AS historyData
FROM 
  ${tableName}
LEFT JOIN 
  ${historyTableName} ON ${tableName}.name = ${historyTableName}.name
WHERE ${historyTableName}.response = 'Bis' and ${historyTableName}.fullDate >= ${raidDate}
GROUP BY 
  ${tableName}.name, ${tableName}.classe;
`
        db.all(query, (err, result) => {
          if (err) reject(new Error(ErrorType.TECHNICAL_UNKNOWN))
          else {
            const array = [];
            for (const res of result) {
              array.push(createBisFromDB(res))
            }
            resolve(array);
          }
        })
        closeDB(db)
      })
    })
  }

  static delete(name) {
    return new Promise((resolve, reject) => {
      const db = openDB();
      db.serialize(() => {
        db.run(`DELETE FROM ${tableName} WHERE name = '${name}'`, (err, roster) => {
          if (err) reject(new Error(ErrorType.TECHNICAL_UNKNOWN))
          else resolve(roster)
        })
      })
      closeDB(db)
    })
  }

  async insert() {
    return new Promise((resolve, reject) => {
      const values = `'${this.name}', '${this.classe}', '${this.role}'`;
      const db = openDB();
      db.serialize(() => {
        db.run(`INSERT INTO ${tableName} (name, classe, role) VALUES (${values})`, err => {
          if (err) reject(new Error(ErrorType.TECHNICAL_UNKNOWN))
          else resolve()
        })
      })
      closeDB(db)
    })
  }

  toJson() {
    return {
      name: this.name,
      classe: this.classe,
      role: this.role
    }
  }
}

export default Roster

function openDB() {
  const env = process.env.NODE_ENV || 'development'
  return new sqlite3.Database(serverConfig.database[env].path, err => {
    if (err) throw new Error(err)
  })
}

function closeDB(db) {
  db.close(err => {
    if (err) throw new Error(err)
  })
}

function createRosterFromDB(dbRoster) {
  return new Roster({
    name: dbRoster.name,
    classe: dbRoster.classe,
    role: dbRoster.role
  })
}

function createBisFromDB(res) {
  const data = {
    tete: 0,
    cou: 0,
    epaules: 0,
    dos: 0,
    torse: 0,
    poignets: 0,
    mains: 0,
    taille: 0,
    jambes: 0,
    pied: 0,
    doigt: 0,
    bijou: 0,
    arme: 0,
    mainGauche: 0,
    relique: 0
  }
  let tokenHM = 0
  let totalBIS = 0
  const histoData = JSON.parse(res.historyData)
  for (const hist of histoData) {
    if (hist.itemName && hist.equipLoc) {
      switch (hist.equipLoc) {
        case 'Tête':
          data.tete += 1
          totalBIS += 1
          break
        case 'Cou':
          data.cou += 1
          totalBIS += 1
          break
        case 'Épaule':
          data.epaules += 1
          totalBIS += 1
          break
        case 'Dos':
          data.dos += 1
          totalBIS += 1
          break
        case 'Torse':
          data.torse += 1
          totalBIS += 1
          break
        case 'Poignets':
          data.poignets += 1
          totalBIS += 1
          break
        case 'Mains':
          data.mains += 1
          totalBIS += 1
          break
        case 'Taille':
          data.taille += 1
          totalBIS += 1
          break
        case 'Jambes':
          data.jambes += 1
          totalBIS += 1
          break
        case 'Pieds':
          data.pied += 1
          totalBIS += 1
          break
        case 'Doigt':
          data.doigt += 1
          totalBIS += 1
          break
        case 'Bijou':
          data.bijou += 1
          totalBIS += 1
          break
        case 'À une main':
        case 'Deux mains':
        case 'Main droite':
          data.arme += 1
          totalBIS += 1
          break
        case 'Tenu(e) en main gauche':
        case 'Main gauche':
          data.mainGauche += 1
          totalBIS += 1
          break
        case 'À distance':
        case 'Relique':
          data.relique += 1
          totalBIS += 1
          break
      }
    }
    if (hist.equipLoc === '') {
      if (hist.itemName.includes('Gantelets')) data.mains += 1
      else if (hist.itemName.includes('Jambières')) data.jambes += 1
      else if (hist.itemName.includes('Couronne')) data.tete += 1
      else if (hist.itemName.includes('Epaulières')) data.epaules += 1
      else if (hist.itemName.includes('Plastron')) data.torse += 1
      else if (hist.itemName.includes('Essence du lugubre')) data.tete += 1
      tokenHM += 1
      totalBIS += 1
    }
  }
  return {
    name: res.name,
    classe: res.classe,
    tokenHM,
    totalBIS,
    data
  }
}