awv3/dist/session/store/connections.js

⚡ AWV3 embedded CAD

'use strict';

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

var _toConsumableArray2 = require('babel-runtime/helpers/toConsumableArray');

var _toConsumableArray3 = _interopRequireDefault(_toConsumableArray2);

var _objectWithoutProperties2 = require('babel-runtime/helpers/objectWithoutProperties');

var _objectWithoutProperties3 = _interopRequireDefault(_objectWithoutProperties2);

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

var _regenerator2 = _interopRequireDefault(_regenerator);

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

var _asyncToGenerator3 = _interopRequireDefault(_asyncToGenerator2);

var _defineProperty2 = require('babel-runtime/helpers/defineProperty');

var _defineProperty3 = _interopRequireDefault(_defineProperty2);

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

var _extends4 = _interopRequireDefault(_extends3);

var _without = require('lodash/without');

var _without2 = _interopRequireDefault(_without);

var _jsonpatch = require('jsonpatch');

var _jsonpatch2 = _interopRequireDefault(_jsonpatch);

var _lifecycle = require('../lifecycle');

var _helpers = require('../helpers');

var _parser = require('../../core/parser');

var _parser2 = _interopRequireDefault(_parser);

var _globals = require('./globals');

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

var scope = 'connections';
var parser = new _parser2.default();
var base = exports.base = (0, _lifecycle.mixin)(scope, connection);

var types = exports.types = (0, _extends4.default)({}, base.types, {
    init: scope + '/init',
    setTree: scope + '/setTree',
    destroyTree: scope + '/destroyTree',
    patchTree: scope + '/patchTree',
    request: scope + '/request',
    message: scope + '/message',
    recalc: scope + '/recalc',
    setName: scope + '/setName',
    setColor: scope + '/setColor',
    setActiveFeature: scope + '/setActiveFeature',
    setDefaultFeatureVisibility: scope + '/setDefaultFeatureVisibility',
    linkPlugins: scope + '/linkPlugins',
    unlinkPlugins: scope + '/unlinkPlugins',
    disableAllPlugins: scope + '/disableAllPlugins',
    updateTree: scope + '/updateTree'
});

var actions = (0, _extends4.default)({}, base.actions, {
    // Basic Redux actions
    setTree: function setTree(id, tree) {
        return { type: types.setTree, id: id, tree: tree };
    },
    destroyTree: function destroyTree(id) {
        return { type: types.destroyTree, id: id };
    },
    patchTree: function patchTree(id, patches) {
        return { type: types.patchTree, id: id, patches: patches };
    },
    message: function message(id, type, _message, reset) {
        var _ref;

        return _ref = { type: types.message, id: id }, (0, _defineProperty3.default)(_ref, 'type', type), (0, _defineProperty3.default)(_ref, 'message', _message), (0, _defineProperty3.default)(_ref, 'reset', reset), _ref;
    },
    setActiveFeature: function setActiveFeature(id) {
        var feature = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : undefined;
        return { type: types.setActiveFeature, id: id, feature: feature };
    },
    setDefaultFeatureVisibility: function setDefaultFeatureVisibility(id, visible) {
        return { type: types.setDefaultFeatureVisibility, id: id, visible: visible };
    },
    linkPlugins: function linkPlugins(id, plugins) {
        return { type: types.linkPlugins, id: id, plugins: plugins };
    },
    unlinkPlugins: function unlinkPlugins(id, plugins) {
        return { type: types.unlinkPlugins, id: id, plugins: plugins };
    },
    updateTree: function updateTree(id, node, attributes) {
        return { type: types.updateTree, id: id, node: node, attributes: attributes };
    },
    // Redux thunks
    connect: function connect(id, url, protocol) {
        return function () {
            var _ref2 = (0, _asyncToGenerator3.default)(_regenerator2.default.mark(function _callee(dispatch) {
                var connection;
                return _regenerator2.default.wrap(function _callee$(_context) {
                    while (1) {
                        switch (_context.prev = _context.next) {
                            case 0:
                                connection = base.references[id];
                                _context.next = 3;
                                return new protocol().connect(url);

                            case 3:
                                connection.socket = _context.sent;

                                connection.socket.on('undo', function (args) {
                                    return dispatch(actions.update(id, { undo: args }));
                                });
                                _context.next = 7;
                                return dispatch(actions.init(id));

                            case 7:
                                connection.emit('connected', connection);

                            case 8:
                            case 'end':
                                return _context.stop();
                        }
                    }
                }, _callee, undefined);
            }));

            return function (_x2) {
                return _ref2.apply(this, arguments);
            };
        }();
    },
    init: function init(id) {
        return function () {
            var _ref3 = (0, _asyncToGenerator3.default)(_regenerator2.default.mark(function _callee2(dispatch) {
                var connection, context;
                return _regenerator2.default.wrap(function _callee2$(_context2) {
                    while (1) {
                        switch (_context2.prev = _context2.next) {
                            case 0:
                                connection = base.references[id];
                                _context2.next = 3;
                                return connection.socket.execute('CADH_SetVar("CC_ProductRefCreation",3);');

                            case 3:
                                _context2.next = 5;
                                return connection.socket.request({ command: 'GetTree' });

                            case 5:
                                context = _context2.sent;

                                dispatch({ type: types.setTree, id: id, tree: context.firstResult });
                                dispatch(actions.message(id, 'success', 'Connected to ' + connection.socket.url));
                                return _context2.abrupt('return', context);

                            case 9:
                            case 'end':
                                return _context2.stop();
                        }
                    }
                }, _callee2, undefined);
            }));

            return function (_x3) {
                return _ref3.apply(this, arguments);
            };
        }();
    },
    request: function request(id, command, factory) {
        var name = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 'send';
        return function (dispatch) {
            var connection = base.references[id];
            var task = patchContext(dispatch, connection, factory);
            dispatch(_globals.actions.beginTask(task.id, command));

            // Make request right away as to not waste time
            var serverCall = connection.socket.requestByName(name, command, task);

            // Results will be handled in queued order instead
            connection.sequence = connection.sequence.then(function () {
                return serverCall.then(function (context) {
                    // If context contains patches, run them
                    context.patches && dispatch(actions.patchTree(id, context.patches));

                    // Error will be collected, too
                    context.errors && context.errors.forEach(function (_ref4) {
                        var errorMessage = _ref4.errorMessage;
                        return dispatch(actions.message(id, 'error', errorMessage));
                    });

                    // Mark task as finished and return full context
                    dispatch(_globals.actions.finishTask(task.id));
                    return context;
                });
            });

            // Return promise
            return connection.sequence;
        };
    },
    stream: function stream(id, url, factory) {
        return function () {
            var _ref5 = (0, _asyncToGenerator3.default)(_regenerator2.default.mark(function _callee3(dispatch) {
                var connection, context;
                return _regenerator2.default.wrap(function _callee3$(_context3) {
                    while (1) {
                        switch (_context3.prev = _context3.next) {
                            case 0:
                                connection = base.references[id];
                                _context3.next = 3;
                                return parser.stream(url, patchContext(dispatch, connection, factory));

                            case 3:
                                context = _context3.sent;

                                context.patches && dispatch(actions.patchTree(id, context.patches));
                                return _context3.abrupt('return', context);

                            case 6:
                            case 'end':
                                return _context3.stop();
                        }
                    }
                }, _callee3, undefined);
            }));

            return function (_x5) {
                return _ref5.apply(this, arguments);
            };
        }();
    },
    parse: function parse(id, blob, factory) {
        return function () {
            var _ref6 = (0, _asyncToGenerator3.default)(_regenerator2.default.mark(function _callee4(dispatch) {
                var connection, context;
                return _regenerator2.default.wrap(function _callee4$(_context4) {
                    while (1) {
                        switch (_context4.prev = _context4.next) {
                            case 0:
                                connection = base.references[id];
                                _context4.next = 3;
                                return parser.parse(blob, patchContext(dispatch, connection, factory));

                            case 3:
                                context = _context4.sent;

                                context.patches && dispatch(actions.patchTree(id, context.patches));
                                return _context4.abrupt('return', context);

                            case 6:
                            case 'end':
                                return _context4.stop();
                        }
                    }
                }, _callee4, undefined);
            }));

            return function (_x6) {
                return _ref6.apply(this, arguments);
            };
        }();
    },
    execute: function execute(id, command) {
        return function (dispatch) {
            return base.references[id].execute(command);
        };
    },
    exportStep: function exportStep(id, path) {
        return function (dispatch) {
            return base.references[id].execute('_C.CADApplication.ExportStep("' + path + '");');
        };
    },
    exportOf1: function exportOf1(id, path) {
        return function (dispatch) {
            return base.references[id].execute('_C.CADApplication.ExportOf1("' + path + '");');
        };
    },
    recalc: function recalc(id) {
        return function (dispatch) {
            return base.references[id].execute('_C.GlobaleFunktionen.UseOnStartRecalc(_O);');
        };
    },
    setColor: function setColor(id, ccid, rgb) {
        return function (dispatch) {
            return base.references[id].execute('_C.CADApplication.SetColor(CADH_RealToId(' + ccid + '),' + rgb.join(',') + ');');
        };
    },
    setName: function setName(id, ccid, name) {
        return function (dispatch) {
            var connection = base.references[id];
            return connection.execute((0, _helpers.buildFeaturePath)(connection.tree, ccid) + '.OBJ_ChangeName("' + (0, _helpers.normalizeName)(name) + '");');
        };
    },
    newPart: function newPart(id) {
        return function (dispatch) {
            dispatch(actions.setActiveFeature(id, undefined));
            dispatch(actions.setDefaultFeatureVisibility(id, true));
            return base.references[id].execute('_C.CADApplication.NewPart();');
        };
    },
    readStream: function readStream(id, ccid, data) {
        var format = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 'step';
        return function (dispatch) {
            var connection = base.references[id];
            return connection.request({
                command: 'Execute',
                task: (0, _helpers.buildFeaturePath)(connection.tree, ccid) + '.ReadStream("data", VOID, "' + format + '");',
                streamData: { data: data }
            });
        };
    },
    load: function load(id, data) {
        return function (dispatch) {
            dispatch(actions.setActiveFeature(id, undefined));
            dispatch(actions.setDefaultFeatureVisibility(id, false));
            return base.references[id].request({
                command: 'Execute',
                task: 'CADH_SetVertexFilter(TRUE); _C.CADApplication.LoadPart("data");',
                streamData: { data: data }
            });
        };
    }
});

exports.actions = actions;
function connection(state, _ref7) {
    var type = _ref7.type,
        payload = (0, _objectWithoutProperties3.default)(_ref7, ['type']);

    switch (type) {
        case types.setTree:
            return (0, _extends4.default)({}, state, { tree: payload.tree });
        case types.destroyTree:
            return (0, _extends4.default)({}, state, { tree: { '1': { id: 1, name: '', class: '', parent: null }, root: 1 } });
        case types.patchTree:
            return (0, _extends4.default)({}, state, { tree: _jsonpatch2.default.apply_patch(state.tree, payload.patches) });
        case types.message:
            return (0, _extends4.default)({}, state, {
                messages: [].concat((0, _toConsumableArray3.default)(state.messages), [{ type: payload.type, message: payload.message, reset: payload.reset }])
            });
        case types.setActiveFeature:
            return (0, _extends4.default)({}, state, { activeFeature: payload.feature });
        case types.setDefaultFeatureVisibility:
            return (0, _extends4.default)({}, state, { defaultFeatureVisibility: payload.visible });
        case types.linkPlugins:
            return (0, _extends4.default)({}, state, {
                plugins: [].concat((0, _toConsumableArray3.default)(state.plugins), (0, _toConsumableArray3.default)(Array.isArray(payload.plugins) ? payload.plugins : [payload.plugins]))
            });
        case types.unlinkPlugins:
            return (0, _extends4.default)({}, state, {
                plugins: _without2.default.apply(undefined, [state.plugins].concat((0, _toConsumableArray3.default)(Array.isArray(payload.plugins) ? payload.plugins : [payload.plugins])))
            });
        case types.updateTree:
            return (0, _extends4.default)({}, state, {
                tree: (0, _extends4.default)({}, state.tree, (0, _defineProperty3.default)({}, payload.node, (0, _extends4.default)({}, state.tree[payload.node], payload.attributes)))
            });
        default:
            return state;
    }
}

function patchContext(dispatch, connection) {
    var factory = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};

    var _createContext = (0, _parser.createContext)(factory),
        options = _createContext.options;

    return (0, _extends4.default)({}, options, connection.session.options, {
        session: session,
        callback: function callback(args) {
            if (args.type === 'Model') {
                connection.session.options.updateMaterials && args.model.updateMaterials();
                connection.session.options.centerGeometry && args.model.centerGeometry();

                var id = args.model.userData.id;
                var previous = connection.primitives[id];

                if (previous) {
                    // TODO: Maybe it would be better to cause actions here
                    // Primitive is already known and needs to be replaced
                    var references = previous.references.slice();
                    previous.destroy();
                    connection.primitives[id] = args.model;
                    args.model.references = [];

                    references.forEach(function (clone) {
                        // Get clones parent
                        var parent = clone.parent;
                        // Destroy clone
                        clone.destroyAsync();
                        // Add new clone to old clones parent
                        if (parent) {
                            // Create new clone and reference it
                            var newClone = args.model.clone();
                            parent.addAsync(newClone);
                            // Reference new clone
                            args.model.references.push(newClone);
                        }
                    });
                } else {
                    // New primitive
                    connection.primitives[id] = args.model;
                    args.model.references = [];

                    if (connection.waiting[id]) {
                        connection.waiting[id].forEach(function (callback) {
                            return callback(args.model);
                        });
                        delete connection.waiting[id];
                        connection.updateView();
                    }
                }
            }
            // Call original callback
            options.callback(args);
            // Call session callback
            connection.session.options.callback && connection.session.options.callback(args);
        }
    });
}

var reducer = exports.reducer = base.reducer;