server/class/DB.js

   1 /**
   2  * DBを操作するクラス
   3  *
   4  * @returns {object}
   5  */
   6 function DB() {
   7     'use strict';
   8
   9     var fs = require('fs');
  10     var Sequelize = require('sequelize');
  11     var co = require('co');
  12     var uuid = require('node-uuid');
  13
  14     var sequelize;
  15     var test = 'hello';
  16
  17     var dbOption = {
  18         dialect: 'sqlite'
  19     };
  20
  21     /**
  22      * sync
  23      *
  24      * @returns {promise}<DBオブジェクトの関数群のオブジェクトをresolveする>
  25      */
  26     function sync() {
  27         return new Promise(function(resolve) {
  28             Files.sync()
  29             .then(function() {
  30                 var root = {
  31                     fileId: '1f83f620-c1ed-11e5-9657-7942989daa00', // rootのuuidは固定値
  32                     name: '/',
  33                     parentId: '',
  34                     fileType: 0
  35                 };
  36                 return Files.create(root);
  37             })
  38             .then(function() {
  39                 var c = {
  40                     sayHello: function() {
  41                         return test;
  42                     },
  43                     getDirectoryParentId: getDirectoryParentId,
  44                     getDirectoryId: getDirectoryId,
  45                     getDirectory: getDirectory,
  46                     existFile: existFile,
  47                     notExistFile: notExistFile,
  48                     existDirectory: existDirectory,
  49                     notExistDirectory: notExistDirectory,
  50                     createFile: createFile,
  51                     removeFile: removeFile,
  52                     createDirectory: createDirectory,
  53                     test1: test1,
  54                     test2: test2
  55                     /*
  56                        removeDirectory: removeDirectory,
  57                        getFilename: getFilename,
  58                        moveFile: moveFile,
  59                        moveDirectory: moveDirectory
  60                        */
  61                 };
  62                 resolve(c);
  63             });
  64         });
  65     }
  66
  67     /**
  68      * getDirectoryParentId
  69      * ディレクトリのparentIdを取得する
  70      * @param name
  71      * @returns {promise} ディレクトリが存在すればresolve(uuid), しなければreject
  72      */
  73     function getDirectoryParentId(name) {
  74         return new Promise(function(resolve, reject) {
  75             var q = {
  76                 where: {
  77                     name: name,
  78                     fileType: 0
  79                 }
  80             };
  81             Files.findAll(q)
  82             .then(function(r) {
  83                 if(r.length === 0) {
  84                     reject(new Error('"' + name + '" directory doesn\'t exist.'));
  85                 } else {
  86                     var map = r.map(function(c) { return c.dataValues.parentId });
  87                     resolve(map);
  88                 }
  89             });
  90         });
  91     }
  92
  93
  94     /**
  95      * getDirectoryId
  96      * ディレクトリのfileIdを取得する
  97      * @param name
  98      * @returns {promise} ディレクトリが存在すればresolve(uuid), しなければreject
  99      */
 100
 101     function getDirectoryId(name) {
 102         return new Promise(function(resolve, reject) {
 103             var q = {
 104                 where: {
 105                     name: name,
 106                     fileType: 0
 107                 }
 108             };
 109             Files.findAll(q)
 110             .then(function(r) {
 111                 if(r.length === 0) {
 112                     reject(new Error('"' + name + '" directory doesn\'t exist.'));
 113                 } else {
 114                     var map = r.map(function(c) { return c.dataValues.fileId });
 115                     resolve(map);
 116                 }
 117             });
 118         });
 119     }
 120
 121     /**
 122      * getDirectory
 123      * ディレクトリのfileIdを取得する
 124      * @param name
 125      * @returns {promise} ディレクトリが存在すればresolve(name), しなければreject
 126      */
 127
 128     function getDirectory(name) {
 129         return new Promise(function(resolve, reject) {
 130             var q = {
 131                 where: {
 132                     name: name,
 133                     fileType: 0
 134                 }
 135             };
 136             Files.findAll(q)
 137             .then(function(r) {
 138                 if(r.length === 0) {
 139                     reject(new Error('"' + name + '" directory doesn\'t exist.'));
 140                 } else {
 141                     var map = r.map(function(c) { return c.dataValues });
 142                     resolve(map);
 143                 }
 144             });
 145         });
 146     }
 147
 148     /**
 149      * existFile
 150      * 同一ディレクトリに同名のファイルが存在することを確かめる
 151      * @param {string} fileName
 152      * @param {string} parentDirectory parentDirectoryの絶対パス
 153      * @returns {promise} ファイルが存在すればresolve、存在しなければreject
 154      */
 155     function existFile(fileName, parentDirectory) {
 156         return new Promise(function(resolve, reject) {
 157             var q = {
 158                 where: {
 159                     name: fileName,
 160                     parentDirectory: parentDirectory,
 161                     fileType: 1
 162                 }
 163             };
 164             Files.findOne(q)
 165             .then(function(r) {
 166                 if(r === null) {
 167                     reject(new Error("\"" + fileName + "\" does not exist in " + '"' + parentDirectory + "\" directory."));
 168                 } else {
 169                     resolve();
 170                 }
 171             });
 172         });
 173     }
 174
 175
 176     /**
 177      * notExistFile
 178      * 同一ディレクトリに同名のファイルが存在していないことを確かめる
 179      * @param {string}fileName
 180      * @param {string}parentDirectory
 181      * @returns {promise} ファイルが存在しなければresolve、存在すればreject
 182      */
 183     function notExistFile(fileName, parentDirectory) {
 184         return new Promise(function(resolve, reject) {
 185             var q = {
 186                 where: {
 187                     name: fileName,
 188                     parentDirectory: parentDirectory,
 189                     fileType: 1
 190                 }
 191             };
 192             Files.findOne(q)
 193             .then(function(r) {
 194                 if(r === null) {
 195                     resolve();
 196                 } else {
 197                     reject(new Error("\"" + fileName + "\" has already existed in " + '"' + parentDirectory + "\" directory."));
 198                 }
 199             });
 200         });
 201     }
 202
 203     /**
 204      * existDirectory
 205      * ディレクトリが存在することを確認する
 206      * @param {string} directory
 207      * @returns {promise} ディレクトリが存在すればresolve、存在しなければreject
 208      */
 209     function existDirectory(directory) {
 210         return new Promise(function(resolve, reject) {
 211             var arrayDirectory = directory.split('/');
 212             arrayDirectory.shift(); // root
 213             arrayDirectory.unshift('/');
 214
 215             var directoriesPromise = arrayDirectory.map(function(name) {
 216                 return getDirectory(name);
 217             });
 218             Promise.all(directoriesPromise)
 219             .then(function(r) {
 220                 var parentId = r[0][0].fileId;
 221                 var index;
 222                 for(var i=1;i<r.length;i++) {
 223                     index = r[i].map(function(c) { return c.parentId }).indexOf(parentId);
 224                     if(index > -1) {
 225                         parentId = r[i][index].fileId;
 226                     } else {
 227                         reject(new Error('"' + directory + '" directory doesn\'t exist.'));
 228                     }
 229                 }
 230                 resolve(directory);
 231             })
 232             .catch(function(error) {
 233                 reject(new Error('"' + directory + '" directory doesn\'t exist.'));
 234             });
 235         });
 236     }
 237
 238     /**
 239      * notExistDirectory
 240      * ディレクトリが存在しないことを確認する
 241      * @param {string} directory
 242      * @returns {promise} ディレクトリが存在しなければresolve、存在すればreject
 243      */
 244     function notExistDirectory(directory) {
 245         return new Promise(function(resolve, reject) {
 246             var q = {
 247                 where: {
 248                     name: directory,
 249                     fileType: 0
 250                 }
 251             };
 252             Files.findOne(q)
 253             .then(function(r) {
 254                 if(r === null) {
 255                     resolve();
 256                 } else {
 257                     reject(new Error('"' + directory + '" directory exists.'));
 258                 }
 259             });
 260         });
 261     }
 262
 263     /**
 264      * createFile
 265      *
 266      * @param fileName
 267      * @param parentDirectory
 268      * @returns {promise}<sequelize.createの結果を格納したobject | Error>
 269      */
 270     function createFile(fileName,parentDirectory) {
 271         return new Promise(function(resolve, reject) {
 272             Promise.all([notExistFile(fileName, parentDirectory), existDirectory(parentDirectory)])
 273             .catch(function(error) {
 274                 reject(error);
 275             })
 276             .then(function() {
 277                 var q = {
 278                     fileId: uuid.v1(),
 279                     name: fileName,
 280                     parentDirectory: parentDirectory,
 281                     fileType: 1
 282                 }
 283                 return Files.create(q)
 284             })
 285             .then(function(r) {
 286                 resolve(r.dataValues.fileId);
 287             });
 288         });
 289     }
 290
 291
 292     /**
 293      * removeFile
 294      * ファイルを削除する
 295      * @param {string} fileName
 296      * @param {string} parentDirectory
 297      * @returns {promise} ファイル削除に成功すればresolve、失敗すればreject
 298      */
 299     function removeFile(fileName, parentDirectory) {
 300         return new Promise(function(resolve, reject) {
 301             existFile(fileName, parentDirectory)
 302             .catch(function(error) {
 303                 reject(error);
 304             })
 305             .then(function() {
 306                 var q = {
 307                     where: {
 308                         name: fileName,
 309                         parentDirectory: parentDirectory
 310                     }
 311                 };
 312                 return Files.destroy(q);
 313             })
 314             .then(function() {
 315                 resolve();
 316             });
 317         });
 318     }
 319
 320     /**
 321      * createDirectory
 322      *
 323      * @param fileName
 324      * @param parentDirectory
 325      * @returns {promise}<sequelize.createの結果を格納したobject | Error>
 326      */
 327     function createDirectory(fileName,parentDirectory) {
 328         return new Promise(function(resolve, reject) {
 329             Promise.all([notExistFile(fileName, parentDirectory), existDirectory(parentDirectory)])
 330             .catch(function(error) {
 331                 reject(error);
 332             })
 333             .then(function() {
 334                 var q = {
 335                     fileId: uuid.v1(),
 336                     name: fileName,
 337                     parentDirectory: parentDirectory,
 338                     fileType: 1
 339                 }
 340                 return Files.create(q)
 341             })
 342             .then(function(r) {
 343                 resolve(r.dataValues.fileId);
 344             });
 345         });
 346     }
 347
 348     /**
 349      * test1
 350      * test用にデータベースのレコードを追加する関数
 351      * @returns {promise}
 352      */
 353     function test1() {
 354         var q = {
 355             fileId: uuid.v1(),
 356             name: 'hoge.txt',
 357             parentId: '1f83f620-c1ed-11e5-9657-7942989daa00', // rootのuuid
 358             fileType: 1
 359         };
 360         return Files.create(q);
 361     }
 362
 363     /**
 364      * test2
 365      * test用にデータベースのレコードを追加する関数
 366      * @returns {promise}
 367      */
 368
 369     function test2() {
 370         var q1 = {
 371             fileId: uuid.v1(),
 372             name: 'one',
 373             parentId: '1f83f620-c1ed-11e5-9657-7942989daa00', // rootのuuid
 374             fileType: 0
 375         };
 376         return Files.create(q1)
 377         .then(function() {
 378             var q2 = {
 379                 fileId: uuid.v1(),
 380                 name: 'two',
 381                 parentId: q1.fileId,
 382                 fileType: 0
 383
 384             };
 385             return Files.create(q2);
 386         })
 387         .then(function(r) {
 388             var q3 = {
 389                 fileId: uuid.v1(),
 390                 name: 'two',
 391                 parentId: '1f83f620-c1ed-11e5-9657-7942989daa00',
 392                 fileType: 0
 393             };
 394             return Files.create(q3);
 395         });
 396     }
 397
 398
 399     /**
 400      *
 401      * @constructor
 402      * @returns {promise}
 403      */
 404     if(process.env['NODE_ENV'] === 'production') {
 405         var dbPath = __dirname + '/../../user-specific-files/db/db.workspace';
 406         dbOption.storage = dbPath;
 407
 408         // if doesn't exist workspace.db, create.
 409         try {
 410             fs.accessSync(dbPath, fs.R_OK | fs.W_OK);
 411         } catch(e) {
 412             fs.writeFileSync(dbPath, '');
 413         }
 414     }
 415
 416     sequelize = new Sequelize('','','', dbOption);
 417
 418     var Files = sequelize.define('file', {
 419         fileId: {
 420             type: Sequelize.UUID,
 421             field: 'file_id',
 422             primaryKey: true
 423         },
 424         name: {
 425             type: Sequelize.STRING,
 426             field: 'name',
 427             allowNull: false
 428         },
 429         parentId: {
 430             type: Sequelize.UUID,
 431             field: 'parent_id',
 432             allowNull: false
 433         },
 434         fileType: {
 435             type: Sequelize.ENUM(0,1),
 436             field: 'file_type',
 437             allowNull: false
 438         }
 439     });
 440
 441     return sync();
 442 }
 443
 444 module.exports = DB;