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
  55   // Optional callback to get error status
  56   add: function(game, callback) {
  57     dbOperation((err, db) => {
  58       if (!!err) {
  59         callback("error");
  60         return;
  61       }
  62       let transaction = db.transaction("games", "readwrite");
  63       transaction.oncomplete = function() {
  64         // Everything's fine
  65         callback();
  66       };
  67       transaction.onerror = function(err) {
  68         // Duplicate key error (most likely)
  69         callback(err);
  70       };
  71       transaction.objectStore("games").add(game);
  72     });
  73   },
  74
  75   // obj: chat, move, fen, clocks, score[Msg], initime, ...
  76   update: function(gameId, obj) {
  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")
  93               game.players[obj[k].idx].name = obj[k].name;
  94             else game[k] = obj[k];
  95           });
  96           objectStore.put(game); //save updated data
  97         }
  98       };
  99     });
 100   },
 101
 102   // Retrieve (all) running local games
 103   getRunning: function(callback) {
 104     dbOperation((err, db) => {
 105       let objectStore = db
 106         .transaction("games", "readonly")
 107         .objectStore("games");
 108       let index = objectStore.index("score");
 109       const range = IDBKeyRange.only("*");
 110       let games = [];
 111       index.openCursor(range).onsuccess = function(event) {
 112         let cursor = event.target.result;
 113         if (!cursor) callback(games);
 114         else {
 115           // If there is still another cursor to go, keep running this code
 116           let g = cursor.value;
 117           // Do not retrieve moves or clocks (unused in list mode)
 118           g.movesCount = g.moves.length;
 119           delete g.moves;
 120           delete g.clocks;
 121           delete g.initime;
 122           games.push(g);
 123           cursor.continue();
 124         }
 125       };
 126     });
 127   },
 128
 129   // Retrieve completed local games
 130   getNext: function(upperDt, callback) {
 131     dbOperation((err, db) => {
 132       let objectStore = db
 133         .transaction("games", "readonly")
 134         .objectStore("games");
 135       let index = objectStore.index("created");
 136       const range = IDBKeyRange.upperBound(upperDt);
 137       let games = [];
 138       index.openCursor(range).onsuccess = function(event) {
 139         let cursor = event.target.result;
 140         if (!cursor) {
 141           // Most recent games first:
 142           games = games.sort((g1, g2) => g2.created - g1.created);
 143           // TODO: 20 games showed per request is arbitrary
 144           callback(games.slice(0, 20));
 145         }
 146         else {
 147           // If there is still another cursor to go, keep running this code
 148           let g = cursor.value;
 149           if (g.score != "*") {
 150             // Do not retrieve moves or clocks (unused in list mode)
 151             g.movesCount = g.moves.length;
 152             delete g.moves;
 153             delete g.clocks;
 154             delete g.initime;
 155             games.push(g);
 156           }
 157           cursor.continue();
 158         }
 159       };
 160     });
 161   },
 162
 163   // Retrieve any game from its identifier.
 164   // NOTE: need callback because result is obtained asynchronously
 165   get: function(gameId, callback) {
 166     dbOperation((err, db) => {
 167       let objectStore = db.transaction("games").objectStore("games");
 168       objectStore.get(gameId).onsuccess = function(event) {
 169         // event.target.result is null if game not found
 170         callback(event.target.result);
 171       };
 172     });
 173   },
 174
 175   // Delete a game in indexedDB
 176   remove: function(gameId, callback) {
 177     dbOperation((err, db) => {
 178       if (!err) {
 179         let transaction = db.transaction("games", "readwrite");
 180         transaction.oncomplete = function() {
 181           callback(); //everything's fine
 182         };
 183         transaction.objectStore("games").delete(gameId);
 184       }
 185     });
 186   }
 187
 188 };