client/src/utils/gameStorage.js

   1 // Game object: {
   2 //   // Static informations:
   3 //   id: string
   4 //   vname: string,
   5 //   fenStart: string,
   6 //   players: array of sid+id+name,
   7 //   cadence: string,
   8 //   increment: integer (seconds),
   9 //   type: string ("live" or "corr")
  10 //   // Game (dynamic) state:
  11 //   fen: string,
  12 //   moves: array of Move objects,
  13 //   clocks: array of integers,
  14 //   initime: array of integers (when clock start running),
  15 //   score: string (several options; '*' == running),
  16 // }
  17
  18 import { store } from "@/store";
  19
  20 function dbOperation(callback) {
  21   let db = null;
  22   let DBOpenRequest = window.indexedDB.open("vchess", 5);
  23
  24   DBOpenRequest.onerror = function(event) {
  25     alert(store.state.tr[
  26       "Database error: stop private browsing, or update your browser"]);
  27     callback("error", null);
  28   };
  29
  30   DBOpenRequest.onsuccess = function() {
  31     db = DBOpenRequest.result;
  32     callback(null, db);
  33     db.close();
  34   };
  35
  36   DBOpenRequest.onupgradeneeded = function(event) {
  37     let db = event.target.result;
  38     let upgradeTransaction = event.target.transaction;
  39     let objectStore = undefined;
  40     if (!db.objectStoreNames.contains("games"))
  41       objectStore = db.createObjectStore("games", { keyPath: "id" });
  42     else
  43       objectStore = upgradeTransaction.objectStore("games");
  44     if (!objectStore.indexNames.contains("score"))
  45       // To sarch games by score (useful for running games)
  46       objectStore.createIndex("score", "score", { unique: false });
  47     if (!objectStore.indexNames.contains("created"))
  48       // To search by date intervals. Two games cannot start at the same time
  49       objectStore.createIndex("created", "created", { unique: true });
  50   };
  51 }
  52
  53 export const GameStorage = {
  54   // Optional callback to get error status
  55   add: function(game, callback) {
  56     dbOperation((err, db) => {
  57       if (!!err) {
  58         callback("error");
  59         return;
  60       }
  61       let transaction = db.transaction("games", "readwrite");
  62       transaction.oncomplete = function() {
  63         // Everything's fine
  64         callback();
  65       };
  66       transaction.onerror = function(err) {
  67         // Duplicate key error (most likely)
  68         callback(err);
  69       };
  70       transaction.objectStore("games").add(game);
  71     });
  72   },
  73
  74   // obj: chat, move, fen, clocks, score[Msg], initime, ...
  75   update: function(gameId, obj) {
  76     // live
  77     dbOperation((err, db) => {
  78       let objectStore = db
  79         .transaction("games", "readwrite")
  80         .objectStore("games");
  81       objectStore.get(gameId).onsuccess = function(event) {
  82         // Ignoring error silently: shouldn't happen now. TODO?
  83         if (event.target.result) {
  84           let game = event.target.result;
  85           // Hidden tabs are delayed, to prevent multi-updates:
  86           if (obj.moveIdx < game.moves.length) return;
  87           Object.keys(obj).forEach(k => {
  88             if (k == "move") game.moves.push(obj[k]);
  89             else if (k == "chat") game.chats.push(obj[k]);
  90             else if (k == "chatRead") game.chatRead = Date.now();
  91             else if (k == "delchat") game.chats = [];
  92             else if (k == "playerName") game.players[obj.idx] = obj.name;
  93             else game[k] = obj[k];
  94           });
  95           objectStore.put(game); //save updated data
  96         }
  97       };
  98     });
  99   },
 100
 101   // Retrieve (all) running local games
 102   getRunning: function(callback) {
 103     dbOperation((err, db) => {
 104       let objectStore = db
 105         .transaction("games", "readonly")
 106         .objectStore("games");
 107       let index = objectStore.index("score");
 108       const range = IDBKeyRange.only("*");
 109       let games = [];
 110       index.openCursor(range).onsuccess = function(event) {
 111         let cursor = event.target.result;
 112         if (!cursor) callback(games);
 113         else {
 114           // If there is still another cursor to go, keep running this code
 115           let g = cursor.value;
 116           // Do not retrieve moves or clocks (unused in list mode)
 117           g.movesCount = g.moves.length;
 118           delete g.moves;
 119           delete g.clocks;
 120           delete g.initime;
 121           games.push(g);
 122           cursor.continue();
 123         }
 124       };
 125     });
 126   },
 127
 128   // Retrieve completed local games
 129   getNext: function(upperDt, callback) {
 130     dbOperation((err, db) => {
 131       let objectStore = db
 132         .transaction("games", "readonly")
 133         .objectStore("games");
 134       let index = objectStore.index("created");
 135       const range = IDBKeyRange.upperBound(upperDt);
 136       let games = [];
 137       index.openCursor(range).onsuccess = function(event) {
 138         let cursor = event.target.result;
 139         if (!cursor) {
 140           // Most recent games first:
 141           games = games.sort((g1, g2) => g2.created - g1.created);
 142           // TODO: 20 games showed per request is arbitrary
 143           callback(games.slice(0, 20));
 144         }
 145         else {
 146           // If there is still another cursor to go, keep running this code
 147           let g = cursor.value;
 148           if (g.score != "*") {
 149             // Do not retrieve moves or clocks (unused in list mode)
 150             g.movesCount = g.moves.length;
 151             delete g.moves;
 152             delete g.clocks;
 153             delete g.initime;
 154             games.push(g);
 155           }
 156           cursor.continue();
 157         }
 158       };
 159     });
 160   },
 161
 162   // Retrieve any game from its identifier.
 163   // NOTE: need callback because result is obtained asynchronously
 164   get: function(gameId, callback) {
 165     dbOperation((err, db) => {
 166       let objectStore = db.transaction("games").objectStore("games");
 167       objectStore.get(gameId).onsuccess = function(event) {
 168         // event.target.result is null if game not found
 169         callback(event.target.result);
 170       };
 171     });
 172   },
 173
 174   // Delete a game in indexedDB
 175   remove: function(gameId, callback) {
 176     dbOperation((err, db) => {
 177       if (!err) {
 178         let transaction = db.transaction("games", "readwrite");
 179         transaction.oncomplete = function() {
 180           callback(); //everything's fine
 181         };
 182         transaction.objectStore("games").delete(gameId);
 183       }
 184     });
 185   }
 186 };