awv3/session/store/tree.js

⚡ AWV3 embedded CAD

"use strict";

Object.defineProperty(exports, "__esModule", {
    value: true
});
exports.reducer = exports.actions = exports.types = undefined;

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

var _regenerator2 = _interopRequireDefault(_regenerator);

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

var _asyncToGenerator3 = _interopRequireDefault(_asyncToGenerator2);

var _jsonpatch = require("jsonpatch");

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

var types = exports.types = {
    init: "SESSION_INIT",
    patch: "SESSION_PATCH",
    request: "SESSION_REQUEST"
};

var actions = exports.actions = {
    init: function init(connection) {
        return function () {
            var _ref = (0, _asyncToGenerator3.default)(_regenerator2.default.mark(function _callee(dispatch) {
                var _ref2, payload;

                return _regenerator2.default.wrap(function _callee$(_context) {
                    while (1) {
                        switch (_context.prev = _context.next) {
                            case 0:
                                _context.next = 2;
                                return connection.request({ command: 'GetTree' });

                            case 2:
                                _ref2 = _context.sent;
                                payload = _ref2.firstResult;

                                dispatch({ type: types.init, payload: payload });
                                return _context.abrupt("return", payload);

                            case 6:
                            case "end":
                                return _context.stop();
                        }
                    }
                }, _callee, undefined);
            }));

            return function (_x) {
                return _ref.apply(this, arguments);
            };
        }();
    },
    request: function request(connection, command, factory) {
        return function () {
            var _ref3 = (0, _asyncToGenerator3.default)(_regenerator2.default.mark(function _callee2(dispatch) {
                var context;
                return _regenerator2.default.wrap(function _callee2$(_context2) {
                    while (1) {
                        switch (_context2.prev = _context2.next) {
                            case 0:
                                _context2.next = 2;
                                return connection.request(command, factory);

                            case 2:
                                context = _context2.sent;

                                if (context.patches) {
                                    dispatch({ type: types.patch, payload: context.patches });
                                }
                                return _context2.abrupt("return", context);

                            case 5:
                            case "end":
                                return _context2.stop();
                        }
                    }
                }, _callee2, undefined);
            }));

            return function (_x2) {
                return _ref3.apply(this, arguments);
            };
        }();
    },
    patch: function patch(payload) {
        return { type: types.patch, payload: payload };
    }
};

var reducer = exports.reducer = function reducer() {
    var state = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
    var _ref4 = arguments[1];
    var type = _ref4.type,
        payload = _ref4.payload;

    switch (type) {
        case types.init:
            return payload;
        case types.patch:
            {
                payload.forEach(function (item) {
                    try {
                        state = (0, _jsonpatch.apply_patch)(state, [item]);
                        /*if (item.value.class === 'CC_VertexReference') {
                            console.log(item.value.id)
                        }*/
                    } catch (e) {
                        var test = item.path.split('/')[1];
                        console.log(item, state[test]);
                    }
                });
                return state; //apply_patch(state, payload);
            }
        default:
            return state;
    }
};