group.js

Generated by CoffeeScript 1.9.1

(function() {
  module.exports = (function() {
    var GPREFIX, PPREFIX, UPREFIX, common, cuid, group, ld, storage;
    ld = require('lodash');
    cuid = require('cuid');
    storage = require('../storage.js');
    common = require('./common.js');
    GPREFIX = storage.DBPREFIX.GROUP;
    UPREFIX = storage.DBPREFIX.USER;
    PPREFIX = storage.DBPREFIX.PAD;
    group = {};
    group.get = ld.partial(common.getDel, false, GPREFIX);
    group.set = function(params, callback) {
      var g;
      common.addSetInit(params, callback, ['name', 'admin']);
      g = group.fn.assignProps(params);
      if (params._id) {
        g._id = params._id;
        return storage.db.get(GPREFIX + g._id, function(err, res) {
          if (err) {
            return callback(err);
          }
          if (!res) {
            return callback(new Error('group does not exist'));
          }
          g.pads = res.pads;
          return group.fn.checkSet(g, callback);
        });
      } else {
        g._id = cuid();
        g.pads = [];
        return group.fn.checkSet(g, callback);
      }
    };
    group.del = function(key, callback) {
      if (!ld.isFunction(callback)) {
        throw new TypeError('callback must be a function');
      }
      return common.getDel(true, GPREFIX, key, function(err, g) {
        if (err) {
          return callback(err);
        }
        return group.fn.indexUsers(true, g, function(err) {
          if (err) {
            return callback(err);
          }
          return group.fn.cascadePads(g, callback);
        });
      });
    };
    group.helper = {};
    group.helper.linkPads = ld.noop;
    group.helper.unlinkPads = ld.noop;
    group.helper.inviteUsers = ld.noop;
    group.helper.setAdmins = ld.noop;
    group.helper.setPassword = ld.noop;
    group.helper.setPublic = ld.noop;
    group.helper.archive = ld.noop;
    group.fn = {};
    group.fn.assignProps = function(params) {
      var g, isValidVisib, p, v, vVal;
      p = params;
      g = {
        name: p.name
      };
      if (ld.isArray(p.admins)) {
        p.admins = ld.filter(p.admins, ld.isString);
      } else {
        p.admins = [];
      }
      g.admins = ld.union([p.admin], p.admins);
      g.users = ld.uniq(p.users);
      v = p.visibility;
      vVal = ['restricted', 'private', 'public'];
      isValidVisib = ld.isString(v) && ld.includes(vVal, v);
      g.visibility = isValidVisib ? v : 'restricted';
      g.password = ld.isString(p.password) ? p.password : null;
      g.readonly = ld.isBoolean(p.readonly) ? p.readonly : false;
      return g;
    };
    group.fn.cascadePads = function(group, callback) {
      var padsKeys;
      if (!ld.isEmpty(group.pads)) {
        padsKeys = ld.map(group.pads, function(p) {
          return PPREFIX + p;
        });
        return storage.fn.delKeys(padsKeys, function(err, res) {
          var e;
          if (err) {
            return callback(err);
          }
          e = 'something goes wrong with cascade pads removal';
          if (!res) {
            return callback(new Error(e));
          }
          return callback(null);
        });
      } else {
        return callback(null);
      }
    };
    group.fn.indexUsers = function(del, group, callback) {
      var usersKeys;
      usersKeys = ld.map(ld.union(group.admins, group.users), function(u) {
        return UPREFIX + u;
      });
      return storage.fn.getKeys(usersKeys, function(err, users) {
        if (err) {
          return callback(err);
        }
        ld.forIn(users, function(u, k) {
          if (del) {
            ld.pull(u.groups, group._id);
          } else {
            if (!ld.includes(u.groups, group._id)) {
              u.groups.push(group._id);
            }
          }
          return users[k] = u;
        });
        return storage.fn.setKeys(users, function(err) {
          if (err) {
            return callback(err);
          }
          return callback(null);
        });
      });
    };
    group.fn.set = function(g, callback) {
      return storage.db.set(GPREFIX + g._id, g, function(err) {
        if (err) {
          return callback(err);
        }
        return group.fn.indexUsers(false, g, function(err) {
          if (err) {
            return callback(err);
          }
          return callback(null, g);
        });
      });
    };
    group.fn.checkSet = function(g, callback) {
      var admins, allKeys, pads, pre, users;
      pre = ld.curry(function(pre, val) {
        return pre + val;
      });
      admins = ld.map(g.admins, pre(UPREFIX));
      users = ld.map(g.users, pre(UPREFIX));
      pads = ld.map(g.pads, pre(PPREFIX));
      allKeys = ld.union(admins, users, pads);
      return common.checkMultiExist(allKeys, function(err, res) {
        var e;
        if (err) {
          return callback(err);
        }
        if (!res) {
          e = 'Some users, admins or pads have not been found';
          return callback(new Error(e));
        }
        return group.fn.set(g, callback);
      });
    };
    return group;
  })();

}).call(this);