clannad/controllers/field.js

data storage service with RESTful APIs.

'use strict';

Object.defineProperty(exports, "__esModule", {
  value: true
});

var _extends2 = require('babel-runtime/helpers/extends');

var _extends3 = _interopRequireDefault(_extends2);

var _regenerator = require('babel-runtime/regenerator');

var _regenerator2 = _interopRequireDefault(_regenerator);

var _asyncToGenerator2 = require('babel-runtime/helpers/asyncToGenerator');

var _asyncToGenerator3 = _interopRequireDefault(_asyncToGenerator2);

var _table = require('../models/table');

var _table2 = _interopRequireDefault(_table);

var _field = require('../models/field');

var _field2 = _interopRequireDefault(_field);

var _resterror = require('../services/resterror');

var _resterror2 = _interopRequireDefault(_resterror);

var _model = require('../services/model');

var _tools = require('../services/tools');

function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }

var select = '-__v -table';
var getFieldQuery = function getFieldQuery(params) {
  var quertArr = ['name', 'type', 'required', 'unique', 'default', 'show', 'validExp', 'index', 'ref'];
  if (params.type !== 'ObjectId' && params.type !== 'ObjectIdArray') params.ref = null;
  return (0, _tools.getQuery)(params, quertArr);
};

exports.default = {
  add: function add(ctx) {
    var _this = this;

    return (0, _asyncToGenerator3.default)(_regenerator2.default.mark(function _callee() {
      var id, table, query, field;
      return _regenerator2.default.wrap(function _callee$(_context) {
        while (1) {
          switch (_context.prev = _context.next) {
            case 0:
              id = ctx.params.id;
              _context.next = 3;
              return _table2.default.findById(id);

            case 3:
              table = _context.sent;

              if (table) {
                _context.next = 6;
                break;
              }

              throw new _resterror2.default(404, 'TABLE_NOTFOUND_ERR', 'table ' + id + ' is not found');

            case 6:
              if (ctx.req.body.type) ;
              query = getFieldQuery(ctx.req.body);
              // 一个表中的字段不可重复

              _context.next = 10;
              return _field2.default.findOne({ table: id, name: query.name });

            case 10:
              field = _context.sent;

              if (!field) {
                _context.next = 13;
                break;
              }

              throw new _resterror2.default(400, 'FIELD_EXIST_ERR', 'field ' + query.name + ' is existed in table ' + table.name);

            case 13:
              query.table = id;
              field = new _field2.default(query);
              if (!table.fields) table.fields = [];
              table.fields.push(field._id);
              _context.next = 19;
              return field.save();

            case 19:
              _context.next = 21;
              return table.save();

            case 21:
              ctx.body = { id: field._id };

            case 22:
            case 'end':
              return _context.stop();
          }
        }
      }, _callee, _this);
    }))();
  },
  del: function del(ctx) {
    var _this2 = this;

    return (0, _asyncToGenerator3.default)(_regenerator2.default.mark(function _callee2() {
      var _ctx$params, id, projectName, field;

      return _regenerator2.default.wrap(function _callee2$(_context2) {
        while (1) {
          switch (_context2.prev = _context2.next) {
            case 0:
              _ctx$params = ctx.params;
              id = _ctx$params.id;
              projectName = _ctx$params.projectName;
              _context2.next = 5;
              return _field2.default.findById(id).populate('table');

            case 5:
              field = _context2.sent;

              if (field) {
                _context2.next = 8;
                break;
              }

              throw new _resterror2.default(404, 'FIELD_NOTFOUND_ERR', 'field ' + id + ' is not found');

            case 8:
              _context2.next = 10;
              return _table2.default.editField({ _id: field.table._id }, 'fields', id);

            case 10:
              _context2.next = 12;
              return (0, _model.removeCaches)(field, projectName, field.table.name);

            case 12:
              _context2.next = 14;
              return field.remove();

            case 14:
            case 'end':
              return _context2.stop();
          }
        }
      }, _callee2, _this2);
    }))();
  },
  edit: function edit(ctx) {
    var _this3 = this;

    return (0, _asyncToGenerator3.default)(_regenerator2.default.mark(function _callee3() {
      var _ctx$params2, projectName, id, query, field, table, key, cache;

      return _regenerator2.default.wrap(function _callee3$(_context3) {
        while (1) {
          switch (_context3.prev = _context3.next) {
            case 0:
              _ctx$params2 = ctx.params;
              projectName = _ctx$params2.projectName;
              id = _ctx$params2.id;
              query = (0, _tools.parseNull)(getFieldQuery(ctx.req.body));
              _context3.next = 6;
              return _field2.default.findById(id);

            case 6:
              field = _context3.sent;
              _context3.next = 9;
              return _table2.default.findById(field.table);

            case 9:
              table = _context3.sent;

              if (table) {
                _context3.next = 12;
                break;
              }

              throw new _resterror2.default(404, 'TABLE_NOTFOUND_ERR', 'table ' + field.table + ' is not found');

            case 12:
              for (key in query) {
                field[key] = query[key];
              }
              _context3.next = 15;
              return field.save();

            case 15:
              _context3.next = 17;
              return (0, _model.getCaches)(projectName);

            case 17:
              _context3.t0 = projectName + '.' + table.name;
              cache = _context3.sent[_context3.t0];
              _context3.next = 21;
              return cache.collection.dropAllIndexes();

            case 21:
            case 'end':
              return _context3.stop();
          }
        }
      }, _callee3, _this3);
    }))();
  },
  list: function list(ctx) {
    var _this4 = this;

    return (0, _asyncToGenerator3.default)(_regenerator2.default.mark(function _callee4() {
      var table, query;
      return _regenerator2.default.wrap(function _callee4$(_context4) {
        while (1) {
          switch (_context4.prev = _context4.next) {
            case 0:
              table = ctx.params.id;
              query = (0, _extends3.default)({}, ctx.query, { table: table });
              _context4.next = 4;
              return (0, _tools.getList)({
                model: _field2.default,
                select: select,
                query: query
              });

            case 4:
              ctx.body = _context4.sent;

            case 5:
            case 'end':
              return _context4.stop();
          }
        }
      }, _callee4, _this4);
    }))();
  },
  count: function count(ctx) {
    var _this5 = this;

    return (0, _asyncToGenerator3.default)(_regenerator2.default.mark(function _callee5() {
      var query, count;
      return _regenerator2.default.wrap(function _callee5$(_context5) {
        while (1) {
          switch (_context5.prev = _context5.next) {
            case 0:
              query = (0, _extends3.default)({ table: ctx.params.id }, ctx.query);
              _context5.next = 3;
              return _field2.default.count(query);

            case 3:
              count = _context5.sent;

              ctx.body = { count: count };

            case 5:
            case 'end':
              return _context5.stop();
          }
        }
      }, _callee5, _this5);
    }))();
  },
  detail: function detail(ctx) {
    var _this6 = this;

    return (0, _asyncToGenerator3.default)(_regenerator2.default.mark(function _callee6() {
      var id, field;
      return _regenerator2.default.wrap(function _callee6$(_context6) {
        while (1) {
          switch (_context6.prev = _context6.next) {
            case 0:
              id = ctx.params.id;
              _context6.next = 3;
              return _field2.default.findById(id, select);

            case 3:
              field = _context6.sent;

              if (field) {
                _context6.next = 6;
                break;
              }

              throw new _resterror2.default(404, 'FIELD_NOTFOUND_ERR', 'field ' + id + ' is not found');

            case 6:
              ctx.body = field;

            case 7:
            case 'end':
              return _context6.stop();
          }
        }
      }, _callee6, _this6);
    }))();
  }
};
module.exports = exports['default'];