src/data/GamesDB.vala

   1 using Gtk;
   2 using Gdk;
   3 using Gee;
   4 using Sqlite;
   5
   6 using GameHub.Utils;
   7
   8 using GameHub.Data.Sources.Steam;
   9 using GameHub.Data.Sources.GOG;
  10 using GameHub.Data.Sources.Humble;
  11
  12 namespace GameHub.Data
  13 {
  14         public class GamesDB
  15         {
  16                 private Database? db = null;
  17
  18                 public GamesDB()
  19                 {
  20                         var path = FSUtils.expand(FSUtils.Paths.Cache.GamesDB);
  21
  22                         if(Database.open(path, out db) != Sqlite.OK)
  23                         {
  24                                 warning("Can't open games database: " + db.errmsg());
  25                                 db = null;
  26                                 return;
  27                         }
  28                 }
  29
  30                 public void create_tables() requires (db != null)
  31                 {
  32                         Statement stmt;
  33                         if(db.prepare_v2("SELECT `playtime` FROM `games`", -1, out stmt) == Sqlite.OK)  // migrate from v1
  34                         {
  35                                 db.exec("DROP TABLE `games`");
  36                         }
  37
  38                         db.exec("CREATE TABLE IF NOT EXISTS `games`(`source` string not null, `id` string not null, `name` string not null, `icon` string, `image` string, `custom_info` string, PRIMARY KEY(`source`, `id`))");
  39                         db.exec("CREATE TABLE IF NOT EXISTS `unsupported_games`(`source` string not null, `id` string not null, PRIMARY KEY(`source`, `id`))");
  40                 }
  41
  42                 public bool add_game(Game game) requires (db != null)
  43                 {
  44                         Statement stmt;
  45                         int res = db.prepare_v2("INSERT OR REPLACE INTO `games`(`source`, `id`, `name`, `icon`, `image`, `custom_info`) VALUES (?, ?, ?, ?, ?, ?)", -1, out stmt);
  46                         assert(res == Sqlite.OK);
  47
  48                         stmt.bind_text(1, game.source.name);
  49                         stmt.bind_text(2, game.id);
  50                         stmt.bind_text(3, game.name);
  51                         stmt.bind_text(4, game.icon);
  52                         stmt.bind_text(5, game.image);
  53                         stmt.bind_text(6, game.custom_info);
  54
  55                         res = stmt.step();
  56
  57                         return res == Sqlite.DONE;
  58                 }
  59
  60                 public bool add_unsupported_game(GameSource src, string id) requires (db != null)
  61                 {
  62                         Statement stmt;
  63                         int res = db.prepare_v2("INSERT OR REPLACE INTO `unsupported_games`(`source`, `id`) VALUES (?, ?)", -1, out stmt);
  64                         assert(res == Sqlite.OK);
  65
  66                         stmt.bind_text(1, src.name);
  67                         stmt.bind_text(2, id);
  68
  69                         res = stmt.step();
  70
  71                         return res == Sqlite.DONE;
  72                 }
  73
  74                 public ArrayList<Game> get_games(GameSource? src = null)
  75                 {
  76                         Statement stmt;
  77                         int res;
  78
  79                         if(src != null)
  80                         {
  81                                 res = db.prepare_v2("SELECT * FROM `games` WHERE `source` = ?", -1, out stmt);
  82                                 res = stmt.bind_text(1, src.name);
  83                         }
  84                         else
  85                         {
  86                                 res = db.prepare_v2("SELECT * FROM `games`", -1, out stmt);
  87                         }
  88
  89                         assert(res == Sqlite.OK);
  90
  91                         var games = new ArrayList<Game>(Game.is_equal);
  92
  93                         while((res = stmt.step()) == Sqlite.ROW)
  94                         {
  95                                 var s = GameSource.by_name(stmt.column_text(0));
  96
  97                                 if(s is Steam)
  98                                 {
  99                                         games.add(new SteamGame.from_db((Steam) s, stmt));
 100                                 }
 101                                 else if(s is GOG)
 102                                 {
 103                                         games.add(new GOGGame.from_db((GOG) s, stmt));
 104                                 }
 105                                 else if(s is Humble)
 106                                 {
 107                                         games.add(new HumbleGame.from_db((Humble) s, stmt));
 108                                 }
 109                         }
 110
 111                         return games;
 112                 }
 113
 114                 public ArrayList<string> get_unsupported_games(GameSource src)
 115                 {
 116                         Statement stmt;
 117                         int res;
 118
 119                         res = db.prepare_v2("SELECT * FROM `unsupported_games` WHERE `source` = ?", -1, out stmt);
 120                         stmt.bind_text(1, src.name);
 121
 122                         var games = new ArrayList<string>();
 123
 124                         while((res = stmt.step()) == Sqlite.ROW)
 125                         {
 126                                 games.add(stmt.column_text(1));
 127                         }
 128
 129                         return games;
 130                 }
 131
 132                 public bool is_game_unsupported(GameSource src, string id)
 133                 {
 134                         Statement stmt;
 135                         int res;
 136
 137                         res = db.prepare_v2("SELECT * FROM `unsupported_games` WHERE `source` = ? AND `id` = ? LIMIT 1", -1, out stmt);
 138                         stmt.bind_text(1, src.name);
 139                         stmt.bind_text(2, id);
 140
 141                         return stmt.step() == Sqlite.ROW;
 142                 }
 143
 144                 private static GamesDB? instance;
 145                 public static unowned GamesDB get_instance()
 146                 {
 147                         if(instance == null)
 148                         {
 149                                 instance = new GamesDB();
 150                         }
 151                         return instance;
 152                 }
 153
 154                 public static void init()
 155                 {
 156                         GamesDB.get_instance().create_tables();
 157                 }
 158         }
 159 }