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