(function(f){if(typeof exports==="object"&&typeof module!=="undefined"){module.exports=f()}else if(typeof define==="function"&&define.amd){define([],f)}else{var g;if(typeof window!=="undefined"){g=window}else if(typeof global!=="undefined"){g=global}else if(typeof self!=="undefined"){g=self}else{g=this}g.AdminPanel = f()}})(function(){var define,module,exports;return (function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(require,module,exports){
"use strict";

module.exports = {
    apiBaseUrl: "https://api.ptflex.net/" //
};

},{}],2:[function(require,module,exports){
'use strict';

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

var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); /*global L, $*/

var _abelkitJs = require('abelkit-js');

var AbelKitWebAdmin = _interopRequireWildcard(_abelkitJs);

function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

var AutocompleteField = function () {

    /**
     * @param inputElementId              {String}
     * @param placeSelectionCallback      {func}
     * @param bounds                      {array}
     * @param abelKit                     {AbelAdminKit}
     * @param completeFromMeetingPoints   {boolean}
     * @param completeFromLocationService {boolean}
     */
    function AutocompleteField(inputElementId, placeSelectionCallback, bounds, abelKit) {
        var _this = this;

        var completeFromMeetingPoints = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : true;
        var completeFromLocationService = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : true;

        _classCallCheck(this, AutocompleteField);

        this.abelKit = abelKit;
        this.placesSelectionCallback = function (data) {
            return placeSelectionCallback(inputElementId, data);
        };

        // meeting point cache
        this.meetingPoints = [];

        // set bounds
        this.bounds = new google.maps.LatLngBounds();
        bounds.map(function (coordinates) {
            var latLng = new google.maps.LatLng(coordinates.lat, coordinates.lng);
            _this.bounds.extend(latLng);
        });

        // initialize autocomplete
        this.initPlacesAutocomplete(inputElementId, completeFromMeetingPoints, completeFromLocationService);
    }

    /**
     * Initialize the Google Places
     * auto complete search input
     *
     * @param inputElementId              {String}
     * @param completeFromMeetingPoints   {boolean}
     * @param completeFromLocationService {boolean}
     */


    _createClass(AutocompleteField, [{
        key: 'initPlacesAutocomplete',
        value: function initPlacesAutocomplete(inputElementId, completeFromMeetingPoints, completeFromLocationService) {
            var _this2 = this;

            // init service
            this.autocomplete = new google.maps.places.AutocompleteService();

            // get container for suggestions
            var suggestionsContainer = $(inputElementId).siblings('.suggestions').get(0);

            // show autocomplete list
            new autoComplete({
                suggestionsContainer: suggestionsContainer,
                selector: inputElementId,
                minChars: 1,
                source: function source(term, suggest) {
                    new Promise(function (resolve, reject) {
                        resolve(this.getAutocompleteList(term, completeFromMeetingPoints, completeFromLocationService));
                    }.bind(_this2)).then(function (results) {
                        return suggest(results);
                    });
                },
                renderItem: this.renderSuggestion,
                onSelect: function onSelect(e, term, item) {
                    return _this2.placeSelected(e, term, item);
                }
            });
        }

        /**
         * Get a list of autocomplete items for
         * a specific search term.
         *
         * @param term
         * @param completeFromMeetingPoints   {boolean}
         * @param completeFromLocationService {boolean}
         *
         * @return {Promise}
         */

    }, {
        key: 'getAutocompleteList',
        value: function getAutocompleteList(term, completeFromMeetingPoints, completeFromLocationService) {
            var _this3 = this;

            var results = [];

            return new Promise(function (resolve, reject) {
                // get suggestions from meeting points
                if (completeFromMeetingPoints) {
                    return _this3.abelKit.AbelAdminService().searchMeetingPoints(term).then(function (data) {
                        var meetingPoints = [];

                        for (var i = 0; i < data.Hits.length; i++) {
                            meetingPoints.push({
                                type: 'map-marker',
                                name: data.Hits[i].name,
                                location: new AbelKitWebAdmin.Objects.AKLocationBase({
                                    locationType: 'gpscoord',
                                    geoType: 'wgs84',
                                    coordinate: {
                                        x: data.Hits[i].longitude,
                                        y: data.Hits[i].latitude
                                    },
                                    POIName: data.Hits[i].name
                                })
                            });
                        }

                        // set meeting points in cache
                        _this3.meetingPoints = meetingPoints;

                        return meetingPoints;
                    }).then(function (meetingPoints) {
                        // add first 4 meetingPoints to result list
                        for (var index = 0; index < 4; ++index) {
                            var meetingPoint = meetingPoints[index];
                            if (meetingPoint == undefined) continue;
                            results.push(meetingPoint);
                        }

                        resolve(results);
                    }).catch(function (error) {
                        return console.warn(error);
                    });
                } else {
                    resolve(results);
                }
            }).then(function (results) {
                // get suggestions from Google Places API
                if (completeFromLocationService) {
                    // find matching places
                    _this3.autocomplete.getPlacePredictions({
                        input: term,
                        bounds: _this3.bounds
                    }, function (predictions, status) {
                        if (status === 'OK') {
                            // add first 4 places results to result list
                            for (var index = 0; index < 4; ++index) {
                                var placeResult = predictions[index];
                                if (placeResult == undefined) continue;
                                results.push(placeResult);
                            }
                        }
                    });
                }

                return results;
            });
        }

        /**
         * Render a single autocomplete suggestion.
         *
         * @param item
         * @param term
         */

    }, {
        key: 'renderSuggestion',
        value: function renderSuggestion(item, term) {
            var placeId = item.place_id || '';
            var name = item.name || '';

            var iconClass = placeId ? 'glyphicon glyphicon-globe' : 'glyphicon glyphicon-map-marker';

            return '<span class="autocomplete-suggestion" data-description="' + item.description + '" data-placeid="' + placeId + '" data-meetingpoint="' + name + '">\n                    <i class="' + iconClass + '"></i>\n                    <strong>' + (item.description || name) + '</strong>\n                </span>';
        }

        /**
         * Handler for a clicked autocomplete
         * list-item.
         *
         * @param e    {Object}
         * @param term {String}
         * @param item {Object}
         */

    }, {
        key: 'placeSelected',
        value: function placeSelected(e, term, item) {
            var placeId = item.dataset.placeid;
            var description = item.dataset.description;

            if (placeId.length > 0) {
                // google places search result
                this.onGooglePlaceClick(placeId, description);
            } else {
                // meeting point
                this.onMeetingPointClick(item);
            }
        }

        /**
         * Handle click on a 'Google Places'
         * autocomplete suggestion
         *
         * @param e {String}
         * @param placeId {String}
         * @param description {String}
         */

    }, {
        key: 'onGooglePlaceClick',
        value: function onGooglePlaceClick(placeId) {
            var _this4 = this;

            var description = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';

            var geocoder = new google.maps.Geocoder();

            geocoder.geocode({ 'placeId': placeId }, function (results, status) {
                if (status === 'OK') {
                    if (results[0]) {
                        var geometry = results[0].geometry;

                        var locationData = {
                            POIName: description,
                            locationType: 'gpscoord',
                            geoType: 'wgs84',
                            coordinate: {
                                x: geometry.location.lat(),
                                y: geometry.location.lng()
                            }
                        };

                        var data = new AbelKitWebAdmin.Objects.AKLocationBase(locationData);

                        _this4.placesSelectionCallback({ location: data });
                    }
                }
            });
        }

        /**
         * Handle click on a meeting point
         * autocomplete suggestion, ie.
         * a bus stop
         *
         * @param item {Object}
         */

    }, {
        key: 'onMeetingPointClick',
        value: function onMeetingPointClick(item) {
            var name = item.dataset.meetingpoint;
            var meetingPoint = this.meetingPoints.find(function (meetingPoint) {
                return meetingPoint.name === name;
            });

            this.placesSelectionCallback(meetingPoint);
        }
    }]);

    return AutocompleteField;
}();

var Autocomplete = function () {
    function Autocomplete(abelKit) {
        var inputElements = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
        var placeSelectionCallback = arguments[2];
        var completeFromMeetingPoints = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : true;
        var completeFromLocationService = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : true;

        _classCallCheck(this, Autocomplete);

        // get contract bounding box
        var boundingBox = abelKit._admin.get('contracts').getSettingForSelectedContract('mapBoundingBox');

        // create instance for each field
        inputElements.map(function (inputElement) {
            return new AutocompleteField(inputElement, placeSelectionCallback, boundingBox, abelKit);
        });

        //Set defaults
        this.timeout = null;
    }

    _createClass(Autocomplete, [{
        key: 'queryAutocomplete',
        value: function queryAutocomplete(query, asyncResults) {
            if (this.completeFromMeetingPoints) {} else {
                this.callBack(asyncResults);
            }
        }
    }, {
        key: 'callBack',
        value: function callBack(asyncResults) {
            this.callBackCalled++;

            if (this.callBackCalled === 2) {
                asyncResults(this.meetingPointsResults.concat(this.locationSearchResults));
            }
        }
    }]);

    return Autocomplete;
}();

exports.default = Autocomplete;

},{"abelkit-js":"abelkit-js"}],3:[function(require,module,exports){
"use strict";

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

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

var BaseController = function BaseController(abelKit) {
    _classCallCheck(this, BaseController);

    this.abelKit = abelKit;
};

exports.default = BaseController;

},{}],4:[function(require,module,exports){
'use strict';

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

var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

/*global L*/

var Map = function () {
    function Map(abelKit) {
        _classCallCheck(this, Map);

        this.abelKit = abelKit;
        this.map = null;
        this.boundingBox = this.abelKit._admin.get('contracts').getSettingForSelectedContract('mapBoundingBox');
    }

    _createClass(Map, [{
        key: 'initialize',
        value: function initialize(elementId) {
            // initialize map
            this.map = new google.maps.Map(document.getElementById(elementId), {
                disableDefaultUI: true,
                zoomControl: true
            });

            this.center();
        }
    }, {
        key: 'center',
        value: function center() {
            if (this.map != null) {
                this.map.fitBounds(this.bounds);
            }
        }
    }, {
        key: 'bounds',
        get: function get() {
            var bounds = new google.maps.LatLngBounds();

            if (typeof this.boundingBox === 'undefined') {
                bounds.extend(new google.maps.LatLng(20, 20));
                bounds.extend(new google.maps.LatLng(40, 40));

                return bounds;
            }

            var minLat = this.boundingBox[0].lat;
            var maxLat = this.boundingBox[0].lat;
            var minLng = this.boundingBox[0].lng;
            var maxLng = this.boundingBox[0].lng;

            var _iteratorNormalCompletion = true;
            var _didIteratorError = false;
            var _iteratorError = undefined;

            try {
                for (var _iterator = this.boundingBox[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
                    var LatLng = _step.value;

                    if (LatLng.lat < minLat) {
                        minLat = LatLng.lat;
                    }
                    if (LatLng.lat > maxLat) {
                        maxLat = LatLng.lat;
                    }
                    if (LatLng.lng < minLng) {
                        minLng = LatLng.lng;
                    }
                    if (LatLng.lng > maxLng) {
                        maxLng = LatLng.lng;
                    }
                }
            } catch (err) {
                _didIteratorError = true;
                _iteratorError = err;
            } finally {
                try {
                    if (!_iteratorNormalCompletion && _iterator.return) {
                        _iterator.return();
                    }
                } finally {
                    if (_didIteratorError) {
                        throw _iteratorError;
                    }
                }
            }

            var lowerBound = new google.maps.LatLng(minLat, minLng);
            var upperBound = new google.maps.LatLng(maxLat, maxLng);

            bounds.extend(lowerBound);
            bounds.extend(upperBound);

            return bounds;
        }
    }]);

    return Map;
}();

exports.default = Map;

},{}],5:[function(require,module,exports){
'use strict';

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

var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();

var _BaseController2 = require('./BaseController');

var _BaseController3 = _interopRequireDefault(_BaseController2);

var _MeetingpointMap = require('./Meetingpoints/MeetingpointMap');

var _MeetingpointMap2 = _interopRequireDefault(_MeetingpointMap);

var _Polygon = require('./Meetingpoints/Polygon');

var _Polygon2 = _interopRequireDefault(_Polygon);

var _abelkitJs = require('abelkit-js');

var AbelKitWebAdmin = _interopRequireWildcard(_abelkitJs);

var _Modal = require('./Meetingpoints/Modal');

var _Modal2 = _interopRequireDefault(_Modal);

var _Uploader = require('./Meetingpoints/Uploader');

var _Uploader2 = _interopRequireDefault(_Uploader);

var _Downloader = require('./Meetingpoints/Downloader');

var _Downloader2 = _interopRequireDefault(_Downloader);

var _PolygonUploader = require('./Meetingpoints/PolygonUploader');

var _PolygonUploader2 = _interopRequireDefault(_PolygonUploader);

var _MeetingpointUploader = require('./Meetingpoints/MeetingpointUploader');

var _MeetingpointUploader2 = _interopRequireDefault(_MeetingpointUploader);

function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }

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

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }

function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } /*global $*/

var MeetingPointController = function (_BaseController) {
    _inherits(MeetingPointController, _BaseController);

    function MeetingPointController(abelKit) {
        _classCallCheck(this, MeetingPointController);

        var _this = _possibleConstructorReturn(this, (MeetingPointController.__proto__ || Object.getPrototypeOf(MeetingPointController)).call(this, abelKit));

        _this.attachListeners();

        //Initialize map
        _this.map = new _MeetingpointMap2.default(abelKit, _this);
        _this.map.initialize('meetingpoints_map');
        _this.importPolygonsFromServer();

        _this.modalDeleteHandler = function () {};
        return _this;
    }

    _createClass(MeetingPointController, [{
        key: 'attachListeners',
        value: function attachListeners() {
            var _this2 = this;

            $('body').on('click', '#meetingpoint_modal_upload', function () {
                $('.tab-pane.active').find('form').submit();
            });

            $('#meetingpoints_upload_item_form').submit(function () {
                //Remove existing polygons if requested
                if ($('#meetingpoints_remove_existing').prop('checked')) {
                    _this2.map.clearAreas();
                }
                var file = $('#meetingpoints_upload_file')[0].files[0];
                var uploader = new _Uploader2.default(file, _this2.map);
                uploader.parse().then(function () {
                    $('#meetingpoints_upload_modal').modal('hide');
                    $('#meetingpoints_upload_file').val('');
                    $.bootstrapGrowl('MeetingPoints added locally. After inspection, press save to send them to the server.', { 'delay': 2000, 'type': 'success' });
                }).catch(function (error) {
                    $.bootstrapGrowl(error, { 'delay': 5000, 'type': 'danger' });
                    $('#meetingpoints_upload_file').val('');
                });
                return false;
            });

            $('#meetingpoints_upload_split_polygons_form').submit(function () {
                var file = $('#polygons_upload_file')[0].files[0];
                var uploader = new _PolygonUploader2.default(_this2.map);

                uploader.parse(file).then(function () {
                    $('#meetingpoints_upload_modal').modal('hide');
                    $('#polygons_upload_file').val('');
                    $.bootstrapGrowl('Polygons added locally. After inspection, press save to send them to the server.', { 'delay': 2000, 'type': 'success' });
                }).catch(function (error) {
                    $.bootstrapGrowl(error, { 'delay': 5000, 'type': 'danger' });
                    $('#polygons_upload_file').val('');
                });
            });

            $('#meetingpoints_upload_split_meetingpoints_form').submit(function () {
                var file = $('#meetingpoints_only_upload_file')[0].files[0];
                var uploader = new _MeetingpointUploader2.default(_this2.map);
                uploader.parse(file).then(function () {
                    $('#meetingpoints_upload_modal').modal('hide');
                    $('#meetingpoints_only_upload_file').val('');
                    $.bootstrapGrowl('MeetingPoints added locally. After inspection, press save to send them to the server.', { 'delay': 2000, 'type': 'success' });
                }).catch(function (error) {
                    $.bootstrapGrowl(error, { 'delay': 5000, 'type': 'danger' });
                    $('#meetingpoints_only_upload_file').val('');
                });
            });
        }

        /**
        * Import meeting points from the server
        */

    }, {
        key: 'importPolygonsFromServer',
        value: function importPolygonsFromServer() {
            var _this3 = this;

            //Show loading image
            var alert = $.bootstrapGrowl('Loading...');

            var idsTouched = [];
            this.abelKit.AbelAdminService().getMeetingPoints().then(function (data) {
                var _iteratorNormalCompletion = true;
                var _didIteratorError = false;
                var _iteratorError = undefined;

                try {
                    var _loop = function _loop() {
                        var serverObject = _step.value;

                        idsTouched.push(serverObject.id);
                        var i = _this3.map.polygons.findIndex(function (l) {
                            return l.serverObject != null && l.serverObject.id == serverObject.id;
                        });

                        if (i != -1) {
                            //Present, update
                            _this3.map.polygons[i].serverObject = new AbelKitWebAdmin.Objects.AKAMeetingPointArea(serverObject);
                        } else {
                            //Not present, add
                            _this3.map.polygons.push(new _Polygon2.default(serverObject, false));
                        }
                    };

                    for (var _iterator = data.polygons[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
                        _loop();
                    }

                    //Convert shifts not present but within the time interval to local shifts
                } catch (err) {
                    _didIteratorError = true;
                    _iteratorError = err;
                } finally {
                    try {
                        if (!_iteratorNormalCompletion && _iterator.return) {
                            _iterator.return();
                        }
                    } finally {
                        if (_didIteratorError) {
                            throw _iteratorError;
                        }
                    }
                }

                _this3.map.polygons = _this3.map.polygons.map(function (l) {
                    if (l.serverObject == null) return l;

                    if (!idsTouched.includes(l.serverObject.id)) {
                        //Convert to local shift
                        l.serverObject = null;
                    }
                    return l;
                });
                alert.alert('close');
                _this3.map.redraw();
            }).catch(function (error) {
                $.bootstrapGrowl(error.message, { 'delay': 2000, 'type': 'danger' });
                throw error;
            });
        }
    }, {
        key: 'importMarkersFromServer',
        value: function importMarkersFromServer(polygon, callback) {
            if (polygon.serverObject == null) {
                callback();
                return;
            }

            var alert = $.bootstrapGrowl('Loading...');

            this.abelKit.AbelAdminService().getMeetingPoint(polygon.serverObject.id).then(function (data) {
                polygon.serverObject.meetingpoints = data.meetingpoints;

                if (!polygon.meetingpointsLoaded && polygon.localObject != null) {
                    var meetingPointsCopy = new AbelKitWebAdmin.Objects.AKAMeetingPoints(data); //Create a new copy
                    polygon.localObject.meetingpoints = meetingPointsCopy.meetingpoints;
                    polygon.meetingpointsLoaded = true;
                }

                callback();
                alert.alert('close');
            }).catch(function (error) {
                $.bootstrapGrowl(error.message, { 'delay': 2000, 'type': 'danger' });
                throw error;
            });
        }
    }, {
        key: 'reset',
        value: function reset() {
            if (confirm('Are you sure?') == true) {
                this.map.reset();
            } else {
                $.bootstrapGrowl('No data reset.', { 'delay': 2000, 'type': 'info' });
            }
        }
    }, {
        key: 'sync',
        value: function sync() {
            this.map.sync();
        }
    }, {
        key: 'onDelete',
        value: function onDelete() {
            // call handler
            this.modalDeleteHandler();

            // hide the modal
            this.modal.hide('meetingpoints_modal');
        }
    }, {
        key: 'showModal',
        value: function showModal(meetingpoint, deleteHandler) {
            var settingsLanguages = this.abelKit._admin.get('contracts').getSettingForSelectedContract('languages');

            // set handler if available
            if (deleteHandler) {
                this.modalDeleteHandler = deleteHandler;
            }

            this.modal = new _Modal2.default(meetingpoint, settingsLanguages, this.abelKit, function () {}, !!deleteHandler);
        }
    }, {
        key: 'download',
        value: function download() {
            new _Downloader2.default(this.map);
        }
    }]);

    return MeetingPointController;
}(_BaseController3.default);

exports.default = MeetingPointController;

},{"./BaseController":3,"./Meetingpoints/Downloader":6,"./Meetingpoints/MeetingpointMap":7,"./Meetingpoints/MeetingpointUploader":8,"./Meetingpoints/Modal":9,"./Meetingpoints/Polygon":10,"./Meetingpoints/PolygonUploader":11,"./Meetingpoints/Uploader":12,"abelkit-js":"abelkit-js"}],6:[function(require,module,exports){
"use strict";

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

var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

var Downloader = function () {
    function Downloader(map) {
        _classCallCheck(this, Downloader);

        this.map = map;
        this.downloadAllMeetingpoints();
    }

    _createClass(Downloader, [{
        key: "downloadAllMeetingpoints",
        value: function downloadAllMeetingpoints() {
            var _this = this;

            this.completePolygons = 0;

            var _iteratorNormalCompletion = true;
            var _didIteratorError = false;
            var _iteratorError = undefined;

            try {
                for (var _iterator = this.map.polygons[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
                    var polygon = _step.value;

                    if (polygon.serverObject !== null && !polygon.meetingpointsLoaded) {
                        //TODO: replace with batch request when available
                        this.map.meetingPointController.importMarkersFromServer(polygon, function () {
                            return _this.completedPolygon();
                        });
                    } else {
                        this.completedPolygon();
                    }
                }
            } catch (err) {
                _didIteratorError = true;
                _iteratorError = err;
            } finally {
                try {
                    if (!_iteratorNormalCompletion && _iterator.return) {
                        _iterator.return();
                    }
                } finally {
                    if (_didIteratorError) {
                        throw _iteratorError;
                    }
                }
            }
        }
    }, {
        key: "completedPolygon",
        value: function completedPolygon() {
            this.completePolygons++;

            if (this.completePolygons === this.map.polygons.length) {
                var data = [["Polygon coordinates-list in JSON format (only fill for first line of polygon)", "Meeting point coordinates in JSON format (only fill for first line of meeting point)", "Language", "Meetingpoint name", "Meeting point description", "Url", "Not available dates"]];

                var _iteratorNormalCompletion2 = true;
                var _didIteratorError2 = false;
                var _iteratorError2 = undefined;

                try {
                    for (var _iterator2 = this.map.polygons[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
                        var polygon = _step2.value;

                        var firstMeetingpoint = true;

                        if (!polygon.hasOwnProperty("localObject") || polygon.localObject === null || !polygon.localObject.hasOwnProperty("meetingpoints")) {
                            // guard for `render-only` polygons
                            continue;
                        }

                        var meetingpoints = polygon.localObject.meetingpoints;
                        if (meetingpoints.length < 1 && polygon.localObject.hasOwnProperty("path")) {
                            // no meetingpoints: only process bounding polygon
                            data.push([JSON.stringify(polygon.localObject.path), "", "", "", ""]);
                        }

                        var _iteratorNormalCompletion3 = true;
                        var _didIteratorError3 = false;
                        var _iteratorError3 = undefined;

                        try {
                            for (var _iterator3 = meetingpoints[Symbol.iterator](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) {
                                var meetingpoint = _step3.value;

                                var firstMeetingpointLanguage = true;
                                var _iteratorNormalCompletion4 = true;
                                var _didIteratorError4 = false;
                                var _iteratorError4 = undefined;

                                try {
                                    for (var _iterator4 = meetingpoint.languages[Symbol.iterator](), _step4; !(_iteratorNormalCompletion4 = (_step4 = _iterator4.next()).done); _iteratorNormalCompletion4 = true) {
                                        var meetingpointLanguage = _step4.value;

                                        data.push([firstMeetingpoint ? JSON.stringify(polygon.localObject.path) : "", firstMeetingpointLanguage ? JSON.stringify(meetingpoint.position) : "", meetingpointLanguage.language, meetingpointLanguage.name, meetingpointLanguage.description, "", meetingpoint.notavailable ? meetingpoint.notavailable : ""]);

                                        firstMeetingpoint = false;
                                        firstMeetingpointLanguage = false;
                                    }
                                } catch (err) {
                                    _didIteratorError4 = true;
                                    _iteratorError4 = err;
                                } finally {
                                    try {
                                        if (!_iteratorNormalCompletion4 && _iterator4.return) {
                                            _iterator4.return();
                                        }
                                    } finally {
                                        if (_didIteratorError4) {
                                            throw _iteratorError4;
                                        }
                                    }
                                }
                            }
                        } catch (err) {
                            _didIteratorError3 = true;
                            _iteratorError3 = err;
                        } finally {
                            try {
                                if (!_iteratorNormalCompletion3 && _iterator3.return) {
                                    _iterator3.return();
                                }
                            } finally {
                                if (_didIteratorError3) {
                                    throw _iteratorError3;
                                }
                            }
                        }
                    }
                } catch (err) {
                    _didIteratorError2 = true;
                    _iteratorError2 = err;
                } finally {
                    try {
                        if (!_iteratorNormalCompletion2 && _iterator2.return) {
                            _iterator2.return();
                        }
                    } finally {
                        if (_didIteratorError2) {
                            throw _iteratorError2;
                        }
                    }
                }

                var now = new Date();
                var exportFilename = "meetingpoints at " + window.location.hostname + " on " + now.toISOString() + ".csv";

                var csvString = data.map(function (row) {
                    return row.map(function (i) {
                        return '"' + i.replace(/"/g, '""') + '"';
                    }).join(",");
                }).join("\n");

                var csvData = new Blob([csvString], {
                    type: "text/csv;charset=utf-8;"
                });
                //IE11 & Edge
                if (navigator.msSaveBlob) {
                    navigator.msSaveBlob(csvData, exportFilename);
                } else {
                    //In FF link must be added to DOM to be clicked
                    var link = document.createElement("a");
                    link.href = window.URL.createObjectURL(csvData);
                    link.setAttribute("download", exportFilename);
                    document.body.appendChild(link);
                    link.click();
                    document.body.removeChild(link);
                }
            }
        }
    }]);

    return Downloader;
}();

exports.default = Downloader;

},{}],7:[function(require,module,exports){
"use strict";

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

var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();

var _get = function get(object, property, receiver) { if (object === null) object = Function.prototype; var desc = Object.getOwnPropertyDescriptor(object, property); if (desc === undefined) { var parent = Object.getPrototypeOf(object); if (parent === null) { return undefined; } else { return get(parent, property, receiver); } } else if ("value" in desc) { return desc.value; } else { var getter = desc.get; if (getter === undefined) { return undefined; } return getter.call(receiver); } };

var _Map2 = require("./../Map/Map");

var _Map3 = _interopRequireDefault(_Map2);

var _Polygon = require("./../Meetingpoints/Polygon");

var _Polygon2 = _interopRequireDefault(_Polygon);

var _abelkitJs = require("abelkit-js");

var AbelKitWebAdmin = _interopRequireWildcard(_abelkitJs);

function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }

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

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }

function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } /* global $ */


var MeetingpointMap = function (_Map) {
    _inherits(MeetingpointMap, _Map);

    function MeetingpointMap(abelKit, meetingPointController) {
        _classCallCheck(this, MeetingpointMap);

        var _this = _possibleConstructorReturn(this, (MeetingpointMap.__proto__ || Object.getPrototypeOf(MeetingpointMap)).call(this, abelKit));

        _this.meetingPointController = meetingPointController;
        _this.drawingManager = null;

        _this.polygons = [];
        _this.markers = [];
        _this.selectedPolygon = false;

        // polygon colors
        _this.polygonColorSelected = "#d9edf7";
        _this.polygonColorSynced = "#63c261";
        _this.polygonColorUnsynced = "#f0ad4e";

        _this.markerOptions = {
            icon: {
                path: "M0-48c-9.8 0-17.7 7.8-17.7 17.4 0 15.5 17.7 30.6 17.7 30.6s17.7-15.4 17.7-30.6c0-9.6-7.9-17.4-17.7-17.4z",
                fillColor: "#583470",
                strokeColor: "#fff",
                fillOpacity: 0.9,
                scale: 0.75,
                strokeWeight: 1
            },
            clickable: true,
            draggable: true,
            zIndex: 2
        };

        _this.polygonOptions = {
            fillColor: _this.polygonColorUnsynced,
            strokeColor: "#999",
            fillOpacity: 0.4,
            strokeOpacity: 0.5,
            strokeWeight: 4,
            clickable: true,
            draggable: false,
            editable: false,
            zIndex: 1
        };
        return _this;
    }

    _createClass(MeetingpointMap, [{
        key: "initialize",
        value: function initialize(elementId) {
            _get(MeetingpointMap.prototype.__proto__ || Object.getPrototypeOf(MeetingpointMap.prototype), "initialize", this).call(this, elementId);

            this.drawingManager = new google.maps.drawing.DrawingManager({
                //drawingMode: google.maps.drawing.OverlayType.MARKER,
                drawingMode: null,
                drawingControl: true,
                drawingControlOptions: {
                    position: google.maps.ControlPosition.TOP_CENTER,
                    drawingModes: ["marker", "polygon"]
                },
                markerOptions: this.markerOptions,
                polygonOptions: this.polygonOptions
            });

            this.drawingManager.setMap(this.map);

            this.attachToolbarListeners();
        }
    }, {
        key: "attachToolbarListeners",
        value: function attachToolbarListeners() {
            var _this2 = this;

            // map click listener
            this.map.addListener("click", function () {
                // because of the stopPropagation calls, this listener only gets
                // events that do not come through a marker or polygon
                _this2.selectPolygon(false);
            });

            // polygon creation listener
            this.drawingManager.addListener("polygoncomplete", function (polygon) {
                // get coordinates for polygon
                var coordinates = [];
                polygon.getPath().forEach(function (position) {
                    return coordinates.push({ x: position.lng(), y: position.lat() });
                });

                // get unique (temporary) id
                var identifier = Date.now();

                var polygonItem = new _Polygon2.default(new AbelKitWebAdmin.Objects.AKAMeetingPointArea({
                    id: identifier,
                    path: coordinates
                }));

                // set area reference
                polygon.meetingpointAreaId = identifier;

                _this2.attachPolygonListener(polygon);

                // set polygons in state
                _this2.polygons.push(polygonItem);
                _this2.polygons.push(polygon);

                _this2.selectPolygon(polygon);
            });

            // marker creation listener
            this.drawingManager.addListener("markercomplete", function (marker) {
                if (!_this2.selectedPolygon) {
                    $.bootstrapGrowl("Select a meeting point first", {
                        delay: 2000,
                        type: "danger"
                    });

                    // don't render marker
                    marker.setMap(null);
                    return;
                }

                // create new meeting point
                var position = marker.getPosition();
                var meetingpoint = new AbelKitWebAdmin.Objects.AKAMeetingPoint({
                    position: { x: position.lng(), y: position.lat() },
                    languages: [],
                    metadata: new AbelKitWebAdmin.Objects.AKAMeetingPointMetadata({
                        url: ""
                    }),
                    notavailable: marker.notavailable
                });

                // add meeting point to area
                var meetingArea = _this2.getSelectedArea();
                if (meetingArea) {
                    meetingArea.localObject.meetingpoints.push(meetingpoint);
                }

                _this2.attachMarkerListener(marker, meetingpoint);

                // set marker in state
                _this2.markers.push(marker);

                _this2.meetingPointController.showModal(meetingpoint);
            });
        }

        /**
         * Attach listeners to a polygon
         *
         * @param polygon {google.maps.Polygon}
         */

    }, {
        key: "attachPolygonListener",
        value: function attachPolygonListener(polygon) {
            var _this3 = this;

            polygon.addListener("click", function (event) {
                // stop event propagation
                event.stop();

                _this3.selectPolygon(polygon);
            });
        }

        /**
         * Attach listeners to a marker
         *
         * @param marker       {google.maps.Marker}
         * @param meetingpoint {AbelKitWebAdmin.Objects.AKAMeetingPoint}
         */

    }, {
        key: "attachMarkerListener",
        value: function attachMarkerListener(marker) {
            var _this4 = this;

            var meetingpoint = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;

            marker.addListener("click", function (event) {
                // stop event propagation
                event.stop();

                if (meetingpoint !== false) {
                    _this4.meetingPointController.showModal(meetingpoint, function () {
                        return _this4.removeMeetingpointMarker(marker, meetingpoint);
                    });
                }
            });
        }

        /**
         * Remove a meetingpoint and it's marker.
         *
         * @param marker       {google.maps.Marker}
         * @param meetingpoint {AbelKitWebAdmin.Objects.AKAMeetingPoint}
         */

    }, {
        key: "removeMeetingpointMarker",
        value: function removeMeetingpointMarker(marker, meetingpoint) {
            var meetingArea = this.getSelectedArea();

            if (meetingArea) {
                // remove meeting point from selected area
                meetingArea.localObject.meetingpoints = meetingArea.localObject.meetingpoints.filter(function (areaMeetingpoint) {
                    return areaMeetingpoint.id !== meetingpoint.id;
                });
            }

            // remove marker
            marker.setMap(null);
        }

        /**
         * Select a specific polygon
         *
         * @param polygon
         */

    }, {
        key: "selectPolygon",
        value: function selectPolygon() {
            var _this5 = this;

            var polygon = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;

            if (polygon === false) {
                this.redrawMeetingpoints(false);
                return;
            }

            if (polygon === this.selectedPolygon) {
                // polygon already selected
                return;
            }

            // deselect all other polygons
            var _iteratorNormalCompletion = true;
            var _didIteratorError = false;
            var _iteratorError = undefined;

            try {
                for (var _iterator = this.polygons[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
                    var polygonItem = _step.value;

                    if (!(polygonItem instanceof _Polygon2.default)) {
                        // set unselected fill color
                        polygonItem.setOptions(Object.assign(this.polygonOptions, {
                            fillColor: this.polygonColorSynced
                        }));
                    }
                }

                // select this polygon
            } catch (err) {
                _didIteratorError = true;
                _iteratorError = err;
            } finally {
                try {
                    if (!_iteratorNormalCompletion && _iterator.return) {
                        _iterator.return();
                    }
                } finally {
                    if (_didIteratorError) {
                        throw _iteratorError;
                    }
                }
            }

            this.selectedPolygon = polygon;
            polygon.setOptions(Object.assign(this.polygonOptions, {
                fillColor: this.polygonColorSelected
            }));
            if (polygon.meetingpointAreaId) {
                // get referenced area
                var meetingArea = this.getSelectedArea();
                if (meetingArea.localObject.reference) {
                    $("#polygon_name").html("Selected polygon: <b>" + meetingArea.localObject.reference + "</b>");
                } else {
                    $("#polygon_name").html("");
                }

                if (meetingArea.localObject.meetingpoints.length > 0) {
                    // meeting points already imported for
                    // polygon: render meeting points
                    this.redrawMeetingpoints(meetingArea);

                    return;
                }

                // import markers
                this.meetingPointController.importMarkersFromServer(meetingArea, function () {
                    if (_this5.selectedPolygon === polygon) {
                        // polygon is still selected: render
                        // meeting points
                        _this5.redrawMeetingpoints(meetingArea);
                    }
                });
            } else {
                this.clearMarkers();
            }
        }

        /**
         * Get the appropriate meeting area for the
         * currently selected polygon.
         *
         * @return Polygon
         */

    }, {
        key: "getSelectedArea",
        value: function getSelectedArea() {
            var selectedPolygon = this.selectedPolygon;

            if (!selectedPolygon.meetingpointAreaId) {
                // no reference to area
                return null;
            }

            return this.polygons.find(function (polygonItem) {
                return polygonItem instanceof _Polygon2.default && polygonItem.hasOwnProperty("localObject") && polygonItem.localObject && polygonItem.localObject.id === selectedPolygon.meetingpointAreaId;
            });
        }

        /**
         * Redraw all polygons.
         */

    }, {
        key: "redraw",
        value: function redraw() {
            this.selectedPolygon = false;
            var counter = 0;
            var _iteratorNormalCompletion2 = true;
            var _didIteratorError2 = false;
            var _iteratorError2 = undefined;

            try {
                for (var _iterator2 = this.polygons[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
                    var polygonItem = _step2.value;

                    if (polygonItem instanceof _Polygon2.default && polygonItem.localObject) {
                        // polygon loaded from the server

                        // construct polygon object
                        var polygon = new google.maps.Polygon(this.polygonOptions);
                        polygon.setPath(polygonItem.localObject.latLngs);
                        polygon.setMap(this.map);
                        this.attachPolygonListener(polygon);

                        // set polygon fill color
                        var fillColor = polygonItem.equal() ? this.polygonColorSynced : this.polygonColorUnsynced;
                        polygon.setOptions(Object.assign(this.polygonOptions, { fillColor: fillColor }));

                        var areaId = polygonItem.localObject.id;
                        if (!areaId) {
                            // new upload: generate unique (temporary) id
                            areaId = Date.now();
                            areaId += counter++;
                            polygonItem.localObject.id = areaId;
                        }

                        // set reference to area
                        polygon.meetingpointAreaId = areaId;

                        // set polygon in state
                        this.polygons.push(polygon);
                    }
                }
            } catch (err) {
                _didIteratorError2 = true;
                _iteratorError2 = err;
            } finally {
                try {
                    if (!_iteratorNormalCompletion2 && _iterator2.return) {
                        _iterator2.return();
                    }
                } finally {
                    if (_didIteratorError2) {
                        throw _iteratorError2;
                    }
                }
            }
        }

        /*
         * Removes all meeting points from view and displays
         * those of a specific polygonId
         */

    }, {
        key: "redrawMeetingpoints",
        value: function redrawMeetingpoints() {
            var polygon = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;

            if (polygon === false) {
                return;
            }

            this.clearMarkers();

            var _iteratorNormalCompletion3 = true;
            var _didIteratorError3 = false;
            var _iteratorError3 = undefined;

            try {
                for (var _iterator3 = polygon.localObject.meetingpoints[Symbol.iterator](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) {
                    var meetingpoint = _step3.value;

                    // construct marker object
                    var marker = new google.maps.Marker(this.markerOptions);
                    var position = new google.maps.LatLng(meetingpoint.position.y, meetingpoint.position.x);
                    marker.setPosition(position);
                    marker.setMap(this.map);
                    this.attachMarkerListener(marker, meetingpoint);

                    // set marker in state
                    this.markers.push(marker);
                }
            } catch (err) {
                _didIteratorError3 = true;
                _iteratorError3 = err;
            } finally {
                try {
                    if (!_iteratorNormalCompletion3 && _iterator3.return) {
                        _iterator3.return();
                    }
                } finally {
                    if (_didIteratorError3) {
                        throw _iteratorError3;
                    }
                }
            }
        }

        /**
         * Remove all markers.
         */

    }, {
        key: "clearMarkers",
        value: function clearMarkers() {
            var _iteratorNormalCompletion4 = true;
            var _didIteratorError4 = false;
            var _iteratorError4 = undefined;

            try {
                for (var _iterator4 = this.markers[Symbol.iterator](), _step4; !(_iteratorNormalCompletion4 = (_step4 = _iterator4.next()).done); _iteratorNormalCompletion4 = true) {
                    var markerItem = _step4.value;

                    // remove from map
                    markerItem.setMap(null);
                }
            } catch (err) {
                _didIteratorError4 = true;
                _iteratorError4 = err;
            } finally {
                try {
                    if (!_iteratorNormalCompletion4 && _iterator4.return) {
                        _iterator4.return();
                    }
                } finally {
                    if (_didIteratorError4) {
                        throw _iteratorError4;
                    }
                }
            }

            this.markers = [];
        }

        /**
         * Remove all meeting areas.
         */

    }, {
        key: "clearAreas",
        value: function clearAreas() {
            var _iteratorNormalCompletion5 = true;
            var _didIteratorError5 = false;
            var _iteratorError5 = undefined;

            try {
                for (var _iterator5 = this.polygons[Symbol.iterator](), _step5; !(_iteratorNormalCompletion5 = (_step5 = _iterator5.next()).done); _iteratorNormalCompletion5 = true) {
                    var polygon = _step5.value;

                    // have it delete on sync with remote
                    polygon.localObject = null;

                    if (polygon instanceof google.maps.Polygon) {
                        // remove polygon from map
                        polygon.setMap(null);
                    }
                }
            } catch (err) {
                _didIteratorError5 = true;
                _iteratorError5 = err;
            } finally {
                try {
                    if (!_iteratorNormalCompletion5 && _iterator5.return) {
                        _iterator5.return();
                    }
                } finally {
                    if (_didIteratorError5) {
                        throw _iteratorError5;
                    }
                }
            }
        }

        /**
         * `Reset` button handler
         */

    }, {
        key: "reset",
        value: function reset() {}
        // this.polygons = this.polygons.filter((i) => i.serverObject != null);
        // for (const polygon of this.polygons) {
        //     polygon.reset();
        // }
        // this.redraw();


        /**
         * `Save` button handler
         */

    }, {
        key: "sync",
        value: function sync() {
            var _iteratorNormalCompletion6 = true;
            var _didIteratorError6 = false;
            var _iteratorError6 = undefined;

            try {
                for (var _iterator6 = this.polygons[Symbol.iterator](), _step6; !(_iteratorNormalCompletion6 = (_step6 = _iterator6.next()).done); _iteratorNormalCompletion6 = true) {
                    var polygonItem = _step6.value;

                    if (polygonItem instanceof _Polygon2.default) {
                        if (polygonItem.equal()) {
                            continue;
                        }

                        var alert = $.bootstrapGrowl("Saving...");

                        if (polygonItem.serverObject && !polygonItem.localObject) {
                            // existing area, no local instance: remove area
                            this.removeRemoteMeetingArea(polygonItem);
                        } else if (polygonItem.serverObject) {
                            // existing area, and local instance: update area
                            this.updateRemoteMeetingArea(polygonItem);
                        } else {
                            // only local instance: create new area
                            this.createRemoteMeetingArea(polygonItem);
                        }

                        alert.alert("close");
                    }
                }
            } catch (err) {
                _didIteratorError6 = true;
                _iteratorError6 = err;
            } finally {
                try {
                    if (!_iteratorNormalCompletion6 && _iterator6.return) {
                        _iterator6.return();
                    }
                } finally {
                    if (_didIteratorError6) {
                        throw _iteratorError6;
                    }
                }
            }

            $.bootstrapGrowl("Meetingpoints saved!", {
                delay: 2000,
                type: "success"
            });
        }

        /**
         * Resource calls to the server.
         */

        /**
         * @param polygon {Polygon}
         */

    }, {
        key: "removeRemoteMeetingArea",
        value: function removeRemoteMeetingArea(polygon) {
            var _this6 = this;

            this.abelKit.AbelAdminService().removeMeetingPoint(polygon.serverObject.id).then(function () {
                var index = _this6.polygons.indexOf(polygon);

                // remove local polygon
                _this6.polygons.splice(index, 1);
            }).catch(function (error) {
                _this6.redraw();

                $.bootstrapGrowl(error.message, {
                    delay: 2000,
                    type: "danger"
                });
            });
        }

        /**
         * @param polygon {Polygon}
         */

    }, {
        key: "updateRemoteMeetingArea",
        value: function updateRemoteMeetingArea(polygon) {
            var _this7 = this;

            this.abelKit.AbelAdminService().updateMeetingPoint(polygon.localObject).then(function () {
                polygon.serverObject = new AbelKitWebAdmin.Objects.AKAMeetingPointArea(polygon.localObject);
            }).catch(function (error) {
                _this7.redraw();

                $.bootstrapGrowl(error.message, {
                    delay: 2000,
                    type: "danger"
                });
            });
        }

        /**
         * @param polygon {Polygon}
         */

    }, {
        key: "createRemoteMeetingArea",
        value: function createRemoteMeetingArea(polygon) {
            var _this8 = this;

            // get temporary id
            var meetingArea = this.polygons.find(function (polygonItem) {
                return !(polygonItem instanceof _Polygon2.default) && polygonItem.meetingpointAreaId === polygon.localObject.id;
            });

            this.abelKit.AbelAdminService().addMeetingPoint(polygon.localObject).then(function (data) {
                var newId = data.return.Id;

                // update existing polygons
                meetingArea.meetingpointAreaId = newId;
                polygon.localObject.id = newId;
                polygon.serverObject = new AbelKitWebAdmin.Objects.AKAMeetingPointArea(polygon.localObject);
            }).catch(function (error) {
                _this8.redraw();

                $.bootstrapGrowl(error.message, {
                    delay: 2000,
                    type: "danger"
                });
            });
        }
    }]);

    return MeetingpointMap;
}(_Map3.default);

exports.default = MeetingpointMap;

},{"./../Map/Map":4,"./../Meetingpoints/Polygon":10,"abelkit-js":"abelkit-js"}],8:[function(require,module,exports){
'use strict';

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

var _slicedToArray = function () { function sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"]) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError("Invalid attempt to destructure non-iterable instance"); } }; }();

var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();

var _papaparse = require('papaparse');

var _papaparse2 = _interopRequireDefault(_papaparse);

var _abelkitJs = require('abelkit-js');

var AbelKitWebAdmin = _interopRequireWildcard(_abelkitJs);

var _Polygon = require('./Polygon');

var _Polygon2 = _interopRequireDefault(_Polygon);

function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }

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

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

var minNumberofColumns = 5;
var maxNumberOfcolumns = 6;

var MeetingpointUploader = function () {
    function MeetingpointUploader(map) {
        _classCallCheck(this, MeetingpointUploader);

        this.map = map;
    }

    _createClass(MeetingpointUploader, [{
        key: 'parse',
        value: function parse(file) {
            var _this = this;

            return new Promise(function (resolve, reject) {
                if (file == undefined || file.name.split('.').pop().toLowerCase() !== 'csv') {
                    throw 'Please provide a valid CSV file to be uploaded.';
                }
                _papaparse2.default.parse(file, {
                    complete: function complete(results) {
                        var data = [];
                        //Remove first line, as it contains headers
                        results.data.shift();
                        var _iteratorNormalCompletion = true;
                        var _didIteratorError = false;
                        var _iteratorError = undefined;

                        try {
                            for (var _iterator = results.data.entries()[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
                                var _step$value = _slicedToArray(_step.value, 2),
                                    i = _step$value[0],
                                    line = _step$value[1];

                                try {
                                    data.push(_this.parseLine(line));
                                } catch (e) {
                                    return reject('File could not be processed as the format is wrong. Please correct the following error: "' + e + '" in the uploaded CSV on line: ' + (i + 1));
                                }
                            }
                        } catch (err) {
                            _didIteratorError = true;
                            _iteratorError = err;
                        } finally {
                            try {
                                if (!_iteratorNormalCompletion && _iterator.return) {
                                    _iterator.return();
                                }
                            } finally {
                                if (_didIteratorError) {
                                    throw _iteratorError;
                                }
                            }
                        }

                        var currentPolygon = null;
                        var currentMeetingpoint = null;

                        var _iteratorNormalCompletion2 = true;
                        var _didIteratorError2 = false;
                        var _iteratorError2 = undefined;

                        try {
                            for (var _iterator2 = data[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
                                var line = _step2.value;

                                if (line.polygon) {
                                    if (!line.polygon.meetingpointsLoaded && line.polygon.localObject != null) {
                                        // polygon has loaded meeting points
                                        line.polygon.meetingpointsLoaded = true;
                                    }
                                    currentPolygon = line.polygon;
                                } else if (!currentPolygon) {
                                    return reject('First data line should contain a polygon name');
                                }

                                if (line.meetingpoint && currentPolygon) {
                                    currentPolygon.localObject.meetingpoints.push(line.meetingpoint);
                                    currentMeetingpoint = line.meetingpoint;
                                }

                                if (currentMeetingpoint) {
                                    currentMeetingpoint.languages.push(line.meetingpointLanguage);
                                } else {
                                    return reject('First data line should contain meeting point coordinates');
                                }
                            }
                        } catch (err) {
                            _didIteratorError2 = true;
                            _iteratorError2 = err;
                        } finally {
                            try {
                                if (!_iteratorNormalCompletion2 && _iterator2.return) {
                                    _iterator2.return();
                                }
                            } finally {
                                if (_didIteratorError2) {
                                    throw _iteratorError2;
                                }
                            }
                        }

                        console.log(currentPolygon);

                        _this.map.redraw();

                        return resolve();
                    },
                    error: function error(err) {
                        reject(err);
                    },
                    header: false,
                    skipEmptyLines: true
                });
            });
        }
    }, {
        key: 'parseLine',
        value: function parseLine(line) {
            if (line.length < minNumberofColumns || line.length > maxNumberOfcolumns) {
                throw 'Line has ' + line.length + ' columns, must have between ' + minNumberofColumns + ' and ' + maxNumberOfcolumns;
            }

            var currentPolygon = null;
            var meetingpoint = null;
            var meetingpointLanguage = void 0;

            var polygonReference = line[0];
            var meetingPointCoordinates = line[1];
            var language = line[2];
            var name = line[3];
            var description = line[4];
            var url = line[5] || ' ';
            var metadata = new AbelKitWebAdmin.Objects.AKAMeetingPointMetadata({
                url: url
            });

            var notavailable = line[6] || '';

            if (meetingPointCoordinates === '') {
                throw 'Please enter coordinates for the meeting point in the following format: {"x":4.904709,"y":52.385554}';
            }

            if (polygonReference !== '') {
                if (!(currentPolygon = this.polygonExists(polygonReference))) {
                    throw 'Could not find polygon: ' + polygonReference + '. The polygon must exist before uploading meeting points.';
                }
            }

            if (meetingPointCoordinates !== '') {
                meetingpoint = new AbelKitWebAdmin.Objects.AKAMeetingPoint({
                    position: JSON.parse(meetingPointCoordinates),
                    languages: [],
                    metadata: metadata,
                    notavailable: notavailable
                });
            }

            meetingpointLanguage = new AbelKitWebAdmin.Objects.AKAMeetingPointLanguage({
                language: language,
                name: name,
                description: description
            });

            return {
                polygon: currentPolygon,
                meetingpoint: meetingpoint,
                meetingpointLanguage: meetingpointLanguage
            };
        }
    }, {
        key: 'polygonExists',
        value: function polygonExists(polygonReference) {
            for (var i = 0; i < this.map.polygons.length; i++) {
                var polygon = this.map.polygons[i];
                if (polygon instanceof _Polygon2.default && polygon.localObject.reference == polygonReference) {
                    return polygon;
                }
            }

            return false;
        }
    }]);

    return MeetingpointUploader;
}();

exports.default = MeetingpointUploader;

},{"./Polygon":10,"abelkit-js":"abelkit-js","papaparse":"papaparse"}],9:[function(require,module,exports){
'use strict';

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

var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); /*global $, Templates */


var _abelkitJs = require('abelkit-js');

var AbelKitWebAdmin = _interopRequireWildcard(_abelkitJs);

function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

var Modal = function () {
    function Modal(meetingpoint, settingsLanguages, abelKit, modalClosedCallback) {
        var deleteHandler = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : false;

        _classCallCheck(this, Modal);

        //this.shift = shift;
        this.abelKit = abelKit;
        this.meetingpoint = meetingpoint;

        //Check that all languages are set for this meeting point. If not, create them
        var _iteratorNormalCompletion = true;
        var _didIteratorError = false;
        var _iteratorError = undefined;

        try {
            for (var _iterator = settingsLanguages[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
                var settingsLanguage = _step.value;

                if (typeof meetingpoint.getLanguage(settingsLanguage.type) == 'undefined') {
                    //Create
                    meetingpoint.languages.push(new AbelKitWebAdmin.Objects.AKAMeetingPointLanguage({
                        language: settingsLanguage.type,
                        name: '',
                        description: ''
                    }));
                }
                //Add languageName property
                var language = meetingpoint.getLanguage(settingsLanguage.type);
                language.languageName = settingsLanguage.name;
            }

            //Load modal into content_container
        } catch (err) {
            _didIteratorError = true;
            _iteratorError = err;
        } finally {
            try {
                if (!_iteratorNormalCompletion && _iterator.return) {
                    _iterator.return();
                }
            } finally {
                if (_didIteratorError) {
                    throw _iteratorError;
                }
            }
        }

        var metadata_keys = this.abelKit._admin.get('contracts').getSettingForSelectedContract('meetingPointMeta');

        // are needed in template
        meetingpoint.metadata_keys = metadata_keys;
        meetingpoint.isDeleteable = deleteHandler;

        $('#meetingpoints_modal_container').html(Templates['settings_meetingpoints_modal'](meetingpoint));
        $('#meetingpoints_modal').modal();
        $('#meetingpoints_modal').on('hide.bs.modal', function () {
            modalClosedCallback();
        });

        var _iteratorNormalCompletion2 = true;
        var _didIteratorError2 = false;
        var _iteratorError2 = undefined;

        try {
            for (var _iterator2 = settingsLanguages[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
                var _settingsLanguage = _step2.value;

                this.attachInputListenerForLanguage(_settingsLanguage.type);
            }
        } catch (err) {
            _didIteratorError2 = true;
            _iteratorError2 = err;
        } finally {
            try {
                if (!_iteratorNormalCompletion2 && _iterator2.return) {
                    _iterator2.return();
                }
            } finally {
                if (_didIteratorError2) {
                    throw _iteratorError2;
                }
            }
        }

        var _iteratorNormalCompletion3 = true;
        var _didIteratorError3 = false;
        var _iteratorError3 = undefined;

        try {
            for (var _iterator3 = metadata_keys[Symbol.iterator](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) {
                var metadata_key = _step3.value;

                this.attachInputListenerForMetadata(metadata_key);
            }
        } catch (err) {
            _didIteratorError3 = true;
            _iteratorError3 = err;
        } finally {
            try {
                if (!_iteratorNormalCompletion3 && _iterator3.return) {
                    _iterator3.return();
                }
            } finally {
                if (_didIteratorError3) {
                    throw _iteratorError3;
                }
            }
        }
    }

    _createClass(Modal, [{
        key: 'attachInputListenerForLanguage',
        value: function attachInputListenerForLanguage(languageType) {
            this.attachInputListener(languageType, 'name');
            this.attachInputListener(languageType, 'description');
        }
    }, {
        key: 'attachInputListenerForMetadata',
        value: function attachInputListenerForMetadata(metadata_key) {
            this.attachInputListenerMeta(metadata_key);
        }
    }, {
        key: 'attachInputListener',
        value: function attachInputListener(languageType, property) {
            var _this = this;

            var element = $('#meetingpoints_' + languageType + '_' + property);
            //element.data('language', language);
            //element.data('property', property);
            element.bind('propertychange change click keyup input paste', function () {
                var language = _this.meetingpoint.getLanguage(languageType);
                language[property] = element.val();
            });
        }
    }, {
        key: 'attachInputListenerMeta',
        value: function attachInputListenerMeta(metadata_key) {
            var _this2 = this;

            var element = $('#meetingpoints_meta_' + metadata_key + '_value');
            //meetingpoints_meta_url_value
            element.bind('propertychange change click keyup input paste', function () {
                var metadata = _this2.meetingpoint.metadata[metadata_key];
                _this2.meetingpoint.metadata[metadata_key] = element.val();
            });
        }
    }, {
        key: 'hide',
        value: function hide(id) {
            var elementId = id ? '#' + id : '#scheduler_modal';

            $(elementId).modal('hide');
        }
    }]);

    return Modal;
}();

exports.default = Modal;

},{"abelkit-js":"abelkit-js"}],10:[function(require,module,exports){
'use strict';

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

var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();

var _abelkitJs = require('abelkit-js');

var AbelKitWebAdmin = _interopRequireWildcard(_abelkitJs);

function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

var Polygon = function () {
    function Polygon(polygon) {
        var localOnly = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;

        _classCallCheck(this, Polygon);

        if (!localOnly) {
            this.serverObject = new AbelKitWebAdmin.Objects.AKAMeetingPointArea(polygon);
        } else {
            this.serverObject = null;
        }
        this.localObject = new AbelKitWebAdmin.Objects.AKAMeetingPointArea(polygon);
        this.meetingpointsLoaded = false;
        this.layerId = null;
    }

    _createClass(Polygon, [{
        key: 'equal',
        value: function equal() {
            var bothNull = this.localObject == null && this.serverObject == null;
            var bothNotNull = this.localObject != null && this.serverObject != null;
            return bothNull || bothNotNull && this.localObject.equal(this.serverObject);
        }
    }, {
        key: 'reset',
        value: function reset() {
            if (this.serverObject != null) {
                this.localObject = new AbelKitWebAdmin.Objects.AKAMeetingPointArea(this.serverObject);
            }
        }
    }]);

    return Polygon;
}();

exports.default = Polygon;

},{"abelkit-js":"abelkit-js"}],11:[function(require,module,exports){
'use strict';

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

var _slicedToArray = function () { function sliceIterator(arr, i) { var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"]) _i["return"](); } finally { if (_d) throw _e; } } return _arr; } return function (arr, i) { if (Array.isArray(arr)) { return arr; } else if (Symbol.iterator in Object(arr)) { return sliceIterator(arr, i); } else { throw new TypeError("Invalid attempt to destructure non-iterable instance"); } }; }();

var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();

var _papaparse = require('papaparse');

var _papaparse2 = _interopRequireDefault(_papaparse);

var _abelkitJs = require('abelkit-js');

var AbelKitWebAdmin = _interopRequireWildcard(_abelkitJs);

var _Polygon = require('./Polygon');

var _Polygon2 = _interopRequireDefault(_Polygon);

function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }

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

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

var numberOfColumns = 2;

var PolygonUploader = function () {
    function PolygonUploader(map) {
        _classCallCheck(this, PolygonUploader);

        this.map = map;
    }

    _createClass(PolygonUploader, [{
        key: 'parse',
        value: function parse(file) {
            var _this = this;

            return new Promise(function (resolve, reject) {
                if (file == undefined || file.name.split('.').pop().toLowerCase() !== 'csv') {
                    throw 'Please provide a valid CSV file to be uploaded.';
                }
                _papaparse2.default.parse(file, {
                    complete: function complete(results) {
                        var data = [];
                        //Remove first line, as it contains headers
                        results.data.shift();
                        var _iteratorNormalCompletion = true;
                        var _didIteratorError = false;
                        var _iteratorError = undefined;

                        try {
                            for (var _iterator = results.data.entries()[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
                                var _step$value = _slicedToArray(_step.value, 2),
                                    i = _step$value[0],
                                    line = _step$value[1];

                                try {
                                    data.push(_this.parseLine(line));
                                } catch (e) {
                                    return reject('File could not be processed as the format is wrong. Please correct the following error: "' + e + '" in the uploaded CSV on line: ' + (i + 1));
                                }
                            }
                        } catch (err) {
                            _didIteratorError = true;
                            _iteratorError = err;
                        } finally {
                            try {
                                if (!_iteratorNormalCompletion && _iterator.return) {
                                    _iterator.return();
                                }
                            } finally {
                                if (_didIteratorError) {
                                    throw _iteratorError;
                                }
                            }
                        }

                        var _iteratorNormalCompletion2 = true;
                        var _didIteratorError2 = false;
                        var _iteratorError2 = undefined;

                        try {
                            for (var _iterator2 = data[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
                                var line = _step2.value;

                                _this.map.polygons.push(line.polygon);
                            }
                        } catch (err) {
                            _didIteratorError2 = true;
                            _iteratorError2 = err;
                        } finally {
                            try {
                                if (!_iteratorNormalCompletion2 && _iterator2.return) {
                                    _iterator2.return();
                                }
                            } finally {
                                if (_didIteratorError2) {
                                    throw _iteratorError2;
                                }
                            }
                        }

                        _this.map.redraw();

                        return resolve();
                    },
                    error: function error(err) {
                        reject(err);
                    },
                    header: false,
                    skipEmptyLines: true
                });
            });
        }
    }, {
        key: 'parseLine',
        value: function parseLine(line) {
            if (line.length !== numberOfColumns) {
                throw 'Line has ' + line.length + ' columns, must have ' + numberOfColumns;
            }

            var polygon = null;
            var polygonReference = line[0];
            var polygonCoordinates = line[1];

            if (polygonReference === '') {
                throw 'Please enter a unique name for the polygon';
            }
            if (polygonCoordinates === '') {
                throw 'Please enter coordinates for the polygon';
            }

            if (!this.isUniquePolygonReference(polygonReference)) {
                throw 'A polygon with the same name: ' + polygonReference + ' already exists. Specify another name.';
            }

            try {
                polygon = new _Polygon2.default({
                    path: JSON.parse(polygonCoordinates),
                    reference: polygonReference
                }, true);
            } catch (e) {
                throw 'The polygon coordinates must be a valid JSON array of points, example format: [{"x":4.82316970825195,"y":52.2540782857686},{"x":4.81252670288085,"y":52.2413612622767}]';
            }

            return {
                polygon: polygon
            };
        }
    }, {
        key: 'isUniquePolygonReference',
        value: function isUniquePolygonReference(polygonReference) {
            var _iteratorNormalCompletion3 = true;
            var _didIteratorError3 = false;
            var _iteratorError3 = undefined;

            try {
                for (var _iterator3 = this.map.polygons[Symbol.iterator](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) {
                    var polygon = _step3.value;

                    if (polygon instanceof _Polygon2.default && polygon.localObject.reference == polygonReference) {
                        return false;
                    }
                }
            } catch (err) {
                _didIteratorError3 = true;
                _iteratorError3 = err;
            } finally {
                try {
                    if (!_iteratorNormalCompletion3 && _iterator3.return) {
                        _iterator3.return();
                    }
                } finally {
                    if (_didIteratorError3) {
                        throw _iteratorError3;
                    }
                }
            }

            return true;
        }
    }]);

    return PolygonUploader;
}();

exports.default = PolygonUploader;

},{"./Polygon":10,"abelkit-js":"abelkit-js","papaparse":"papaparse"}],12:[function(require,module,exports){
'use strict';

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

var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();

var _abelkitJs = require('abelkit-js');

var AbelKitWebAdmin = _interopRequireWildcard(_abelkitJs);

var _Polygon = require('./Polygon');

var _Polygon2 = _interopRequireDefault(_Polygon);

var _papaparse = require('papaparse');

var _papaparse2 = _interopRequireDefault(_papaparse);

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

function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

var Uploader = function () {
    function Uploader(file, map) {
        _classCallCheck(this, Uploader);

        this.file = file;
        this.map = map;
    }

    /*
        Parse the CSV
    */


    _createClass(Uploader, [{
        key: 'parse',
        value: function parse() {
            var _this = this;

            return new Promise(function (resolve, reject) {
                _papaparse2.default.parse(_this.file, {
                    complete: function complete(results) {
                        var data = [];
                        //Remove first line, as it contains headers
                        results.data.shift();

                        var _iteratorNormalCompletion = true;
                        var _didIteratorError = false;
                        var _iteratorError = undefined;

                        try {
                            for (var _iterator = results.data[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
                                var line = _step.value;

                                try {
                                    data.push(_this.parseLine(line));
                                } catch (e) {
                                    reject(e);
                                }
                            }
                        } catch (err) {
                            _didIteratorError = true;
                            _iteratorError = err;
                        } finally {
                            try {
                                if (!_iteratorNormalCompletion && _iterator.return) {
                                    _iterator.return();
                                }
                            } finally {
                                if (_didIteratorError) {
                                    throw _iteratorError;
                                }
                            }
                        }

                        var currentPolygon = null;
                        var currentMeetingpoint = null;

                        var _iteratorNormalCompletion2 = true;
                        var _didIteratorError2 = false;
                        var _iteratorError2 = undefined;

                        try {
                            for (var _iterator2 = data[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
                                var _line = _step2.value;

                                if (_line.polygon) {
                                    if (!_line.polygon.meetingpointsLoaded && _line.polygon.localObject != null) {
                                        // polygon has loaded meeting points
                                        _line.polygon.meetingpointsLoaded = true;
                                    }

                                    _this.map.polygons.push(_line.polygon);
                                    currentPolygon = _line.polygon;
                                } else if (!currentPolygon) {
                                    reject('First data line should contain a polygon coordinates-list');
                                }

                                if (_line.meetingpoint && currentPolygon) {
                                    currentPolygon.localObject.meetingpoints.push(_line.meetingpoint);
                                    currentMeetingpoint = _line.meetingpoint;
                                }

                                if (currentMeetingpoint) {
                                    currentMeetingpoint.languages.push(_line.meetingpointLanguage);
                                } else {
                                    reject('First data line should contain meeting point coordinates');
                                }
                            }
                        } catch (err) {
                            _didIteratorError2 = true;
                            _iteratorError2 = err;
                        } finally {
                            try {
                                if (!_iteratorNormalCompletion2 && _iterator2.return) {
                                    _iterator2.return();
                                }
                            } finally {
                                if (_didIteratorError2) {
                                    throw _iteratorError2;
                                }
                            }
                        }

                        _this.map.redraw();

                        resolve();
                    },
                    error: function error(err) {
                        reject(err);
                    },
                    header: false,
                    skipEmptyLines: true
                });
            });
        }
    }, {
        key: 'parseLine',
        value: function parseLine(line) {
            if (line.length < 5) throw 'Line only has ' + line.length + ' columns.';

            var polygon = null;
            var meetingpoint = null;
            var meetingpointLanguage = null;
            try {
                var polygonCoordinates = line[0];
                var meetingPointCoordinates = line[1];
                var language = line[2];
                var name = line[3];
                var description = line[4];

                if (polygonCoordinates != '') {
                    polygon = new _Polygon2.default({
                        path: JSON.parse(polygonCoordinates)
                    }, true);
                }

                // TODO: make this dynamic, instead of only url
                var url = line[5] || ' ';
                var metadata = new AbelKitWebAdmin.Objects.AKAMeetingPointMetadata({
                    url: url
                });

                var notavailable = line[6] || '';

                if (meetingPointCoordinates != '') {
                    meetingpoint = new AbelKitWebAdmin.Objects.AKAMeetingPoint({
                        position: JSON.parse(meetingPointCoordinates),
                        languages: [],
                        metadata: metadata,
                        notavailable: notavailable
                    });
                }

                meetingpointLanguage = new AbelKitWebAdmin.Objects.AKAMeetingPointLanguage({
                    language: language,
                    name: name,
                    description: description
                });
            } catch (e) {
                throw e.message.message;
            }

            return {
                polygon: polygon,
                meetingpoint: meetingpoint,
                meetingpointLanguage: meetingpointLanguage
            };
        }
    }]);

    return Uploader;
}();

exports.default = Uploader;

},{"./Polygon":10,"abelkit-js":"abelkit-js","papaparse":"papaparse"}],13:[function(require,module,exports){
'use strict';

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

var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();

var _BaseController2 = require('./BaseController');

var _BaseController3 = _interopRequireDefault(_BaseController2);

var _Autocomplete = require('./Autocomplete/Autocomplete');

var _Autocomplete2 = _interopRequireDefault(_Autocomplete);

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

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }

function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } /*global $*/

var PromocodeController = function (_BaseController) {
    _inherits(PromocodeController, _BaseController);

    function PromocodeController(abelKit) {
        _classCallCheck(this, PromocodeController);

        var _this = _possibleConstructorReturn(this, (PromocodeController.__proto__ || Object.getPrototypeOf(PromocodeController)).call(this, abelKit));

        var placeSelectionCallback = function placeSelectionCallback(evt, suggestion) {
            var which = 'to';
            if (evt.target.id == 'promocode_from') {
                which = 'from';
            }
            $('#promocode_' + which + '_street_number').val(suggestion.location.houseNumber);
            $('#promocode_' + which + '_route').val(suggestion.location.street);
            $('#promocode_' + which + '_locality').val(suggestion.location.place);
            $('#promocode_' + which + '_country').val(suggestion.location.countryCode);
            $('#promocode_' + which + '_postal_code').val(suggestion.location.zip);
            $('#promocode_' + which + '_poi_name').val(suggestion.location.POIName);
            $('#promocode_' + which + '_lat').val(suggestion.location.coordinate.y);
            $('#promocode_' + which + '_lng').val(suggestion.location.coordinate.x);
            $('#promocode_' + which + '_active').prop('checked', true);
        };

        _this.autocomplete = new _Autocomplete2.default(abelKit, ['#promocode_from', '#promocode_to'], placeSelectionCallback, true, true);
        return _this;
    }

    _createClass(PromocodeController, [{
        key: 'new',
        value: function _new() {
            var _this2 = this;

            $('#promocode_from, #promocode_to').keydown(function (evt) {
                var keycode = event.keyCode;
                var valid = keycode > 47 && keycode < 58 || // number keys
                keycode > 64 && keycode < 91 || // letter keys
                keycode > 95 && keycode < 112 || // numpad keys
                keycode > 185 && keycode < 193 || // ;=,-./` (in order)
                keycode > 218 && keycode < 223; // [\]' (in order)

                if (valid) {
                    var which = 'to';
                    if (evt.target.id == 'promocode_from') {
                        which = 'from';
                    }
                    _this2.clearLocation(which);
                }
            });
        }
    }, {
        key: 'clearLocation',
        value: function clearLocation(which) {
            $('#promocode_' + which + '_street_number').val('');
            $('#promocode_' + which + '_route').val('');
            $('#promocode_' + which + '_locality').val('');
            $('#promocode_' + which + '_country').val('');
            $('#promocode_' + which + '_postal_code').val('');
            $('#promocode_' + which + '_poi_name').val('');
            $('#promocode_' + which + '_lat').val('');
            $('#promocode_' + which + '_lng').val('');
        }
    }]);

    return PromocodeController;
}(_BaseController3.default);

exports.default = PromocodeController;

},{"./Autocomplete/Autocomplete":2,"./BaseController":3}],14:[function(require,module,exports){
'use strict';

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

var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();

var _BaseController2 = require('./BaseController');

var _BaseController3 = _interopRequireDefault(_BaseController2);

var _Canvas = require('./Scheduler/Canvas');

var _Canvas2 = _interopRequireDefault(_Canvas);

var _Shift = require('./Scheduler/Shift');

var _Shift2 = _interopRequireDefault(_Shift);

var _Modal = require('./Scheduler/Modal');

var _Modal2 = _interopRequireDefault(_Modal);

var _Uploader = require('./Scheduler/Uploader');

var _Uploader2 = _interopRequireDefault(_Uploader);

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

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }

function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } /*global moment, $*/

/*
  TODO:
  - automatically fill vehicle and location based on driver chosen
  - auto generate bars
  - render stats (basic)
  - use 15 min grid for shift start/ end
  D3 API: https://github.com/d3/d3/blob/master/API.md

*/

//import Statistics from './Scheduler/Statistics';


var SchedulerController = function (_BaseController) {
    _inherits(SchedulerController, _BaseController);

    function SchedulerController(abelKit) {
        _classCallCheck(this, SchedulerController);

        var _this = _possibleConstructorReturn(this, (SchedulerController.__proto__ || Object.getPrototypeOf(SchedulerController)).call(this, abelKit));

        var now = moment().tz(abelKit._admin.get('timezone'));
        _this.attachListeners();

        //Initialize with today
        _this.canvas = new _Canvas2.default('#scheduler_container', 400, now.startOf('day').toDate(), now.endOf('day').toDate(), function (shift) {
            _this.showModal(shift);
        }, function (shift, successCallback) {
            _this.removeShift(shift, successCallback);
        }, _this.abelKit._admin.get('contracts').getSettingForSelectedContract('vehicleTypes')[0]);

        _this.changeDate([]);
        return _this;
    }

    /**
    * Import shifts from the server for a specific time frame without discarding local changes
    */


    _createClass(SchedulerController, [{
        key: 'importFromServer',
        value: function importFromServer(startTime, endTime) {
            var _this2 = this;

            //Show loading image
            var alert = $.bootstrapGrowl('Loading...');
            var importStepsCompleted = 0;

            var importStepCompleted = function importStepCompleted() {
                importStepsCompleted++;
                if (importStepsCompleted == 2) {
                    alert.alert('close');
                    _this2.canvas.render();
                }
            };

            var idsTouched = [];
            this.abelKit.AbelAdminService().getShifts(startTime, endTime).then(function (data) {
                var _iteratorNormalCompletion = true;
                var _didIteratorError = false;
                var _iteratorError = undefined;

                try {
                    var _loop = function _loop() {
                        var serverShift = _step.value;

                        idsTouched.push(serverShift.shiftId);
                        var i = _this2.canvas.shifts.findIndex(function (l) {
                            return l.type != 'local' && l.serverShift.shiftId == serverShift.shiftId;
                        });

                        if (i != -1) {
                            //Present, update
                            _this2.canvas.shifts[i].serverShift = serverShift;
                        } else {
                            //Not present, add
                            _this2.canvas.shifts.push(new _Shift2.default(serverShift));
                        }
                    };

                    for (var _iterator = data.shifts[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
                        _loop();
                    }

                    //Convert shifts not present but within the time interval to local shifts
                } catch (err) {
                    _didIteratorError = true;
                    _iteratorError = err;
                } finally {
                    try {
                        if (!_iteratorNormalCompletion && _iterator.return) {
                            _iterator.return();
                        }
                    } finally {
                        if (_didIteratorError) {
                            throw _iteratorError;
                        }
                    }
                }

                _this2.canvas.shifts = _this2.canvas.shifts.map(function (l) {
                    if (l.type == 'local') return l;

                    var isInInterval = !(l.serverShift.startTime >= endTime || l.serverShift.endTime <= startTime);
                    if (!idsTouched.includes(l.serverShift.shiftId) && isInInterval) {
                        //Convert to local shift
                        l.type = 'local';
                        l.serverShift = null;
                    }
                    return l;
                });
                importStepCompleted();
            }).catch(function (error) {
                $.bootstrapGrowl(error.message, { 'delay': 2000, 'type': 'danger' });
            });

            this.abelKit.AbelAdminService().getTripForecast(startTime, endTime).then(function (data) {
                //Remove all statistics for this period
                _this2.canvas.statistics = _this2.canvas.statistics.filter(function (l) {
                    return l.startTime >= endTime || l.endTime <= startTime;
                });
                _this2.canvas.statistics = _this2.canvas.statistics.concat(data.tripForecast);
                importStepCompleted();
            }).catch(function (error) {
                $.bootstrapGrowl(error.message, { 'delay': 2000, 'type': 'danger' });
            });
        }
    }, {
        key: 'showModal',
        value: function showModal(shift) {
            var _this3 = this;

            var mapBoundingBox = this.abelKit._admin.get('contracts').getSettingForSelectedContract('mapBoundingBox');
            var vehicleTypes = this.abelKit._admin.get('contracts').getSettingForSelectedContract('vehicleTypes');
            this.modal = new _Modal2.default(shift, mapBoundingBox, vehicleTypes, function () {
                _this3.canvas.render();
            }, this.abelKit);
        }
    }, {
        key: 'saveModal',
        value: function saveModal() {
            if (this.modal.checkValues()) {
                this.modal.hide();
                this.canvas.render();
            } else {
                $.bootstrapGrowl('Please solve all red input boxes.', { 'delay': 2000, 'type': 'danger' });
            }
        }

        //Triggered in modal

    }, {
        key: 'resetModalShift',
        value: function resetModalShift() {
            if (confirm('Are you sure?') == true) {
                this.modal.resetShift();
                this.modal.hide();
                this.canvas.render();
            } else {
                $.bootstrapGrowl('No data reset.', { 'delay': 2000, 'type': 'info' });
            }
        }
    }, {
        key: 'resetShifts',
        value: function resetShifts() {
            if (confirm('Are you sure?') == true) {
                this.canvas.shifts = this.canvas.shifts.filter(function (v) {
                    return v.type != 'local';
                });
                var _iteratorNormalCompletion2 = true;
                var _didIteratorError2 = false;
                var _iteratorError2 = undefined;

                try {
                    for (var _iterator2 = this.canvas.shifts[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
                        var shift = _step2.value;

                        shift.reset();
                    }
                } catch (err) {
                    _didIteratorError2 = true;
                    _iteratorError2 = err;
                } finally {
                    try {
                        if (!_iteratorNormalCompletion2 && _iterator2.return) {
                            _iterator2.return();
                        }
                    } finally {
                        if (_didIteratorError2) {
                            throw _iteratorError2;
                        }
                    }
                }

                this.canvas.render();
            } else {
                $.bootstrapGrowl('No data reset.', { 'delay': 2000, 'type': 'info' });
            }
        }

        //Triggered in modal

    }, {
        key: 'removeModalShift',
        value: function removeModalShift() {
            var _this4 = this;

            this.removeShift(this.modal.shift, function () {
                _this4.canvas.shifts = _this4.canvas.shifts.filter(function (l) {
                    return !(l.localShift.shiftId == _this4.modal.shift.localShift.shiftId && l.type == _this4.modal.shift.type);
                });
                _this4.modal.hide();
            });
        }
    }, {
        key: 'removeShift',
        value: function removeShift(shift, successCallback) {
            if (confirm('Are you sure?') == true) {
                if (shift.type == 'local') {
                    successCallback();
                } else {
                    this.abelKit.AbelAdminService().removeShift(shift.serverShift).then(function () {
                        successCallback();
                    }).catch(function (error) {
                        $.bootstrapGrowl(error.message, { 'delay': 2000, 'type': 'danger' });
                    });
                }
            } else {
                $.bootstrapGrowl('No changes made.', { 'delay': 2000, 'type': 'info' });
            }
        }
    }, {
        key: 'driverlogOnFromModalShift',
        value: function driverlogOnFromModalShift() {
            var _this5 = this;

            if (typeof this.modal.shift.localShift.driver == 'undefined') {
                $.bootstrapGrowl('A specific driver is required to start a shift', { 'delay': 2000, 'type': 'danger' });
                return;
            }
            if (typeof this.modal.shift.localShift.vehicle.licensePlate == 'undefined' || this.modal.shift.localShift.vehicle.licensePlateVehicles == '') {
                $.bootstrapGrowl('A specific vehicle is required to start a shift', { 'delay': 2000, 'type': 'danger' });
                return;
            }

            this.abelKit.AbelAdminService().driverLogOn(this.modal.shift.localShift.AKAAddShift).then(function (data) {
                _this5.processUpdatedServerShift(data.shift, _this5.modal.shift);
                _this5.canvas.render();
                _this5.modal.hide();
            }).catch(function (error) {
                $.bootstrapGrowl(error.message, { 'delay': 2000, 'type': 'danger' });
            });
        }
    }, {
        key: 'driverlogOffFromModalShift',
        value: function driverlogOffFromModalShift() {
            var _this6 = this;

            if (typeof this.modal.shift.localShift.driver == 'undefined') {
                $.bootstrapGrowl('No driver is specified', { 'delay': 2000, 'type': 'danger' });
                return;
            }

            this.abelKit.AbelAdminService().driverLogOff(this.modal.shift.localShift.driver.id).then(function (data) {
                _this6.processUpdatedServerShift(data.shift, _this6.modal.shift);
                _this6.canvas.render();
                _this6.modal.hide();
            }).catch(function (error) {
                $.bootstrapGrowl(error.message, { 'delay': 2000, 'type': 'danger' });
            });
        }
    }, {
        key: 'syncShifts',
        value: function syncShifts() {
            var _this7 = this;

            var _loop2 = function _loop2(_i) {
                var shift = _this7.canvas.shifts[_i];
                if (!shift.equal()) {
                    if (shift.type != 'local') {
                        //Update = remove + add
                        var alert = $.bootstrapGrowl('Saving...');
                        _this7.abelKit.AbelAdminService().removeShift(shift.serverShift).then(function () {
                            _this7.abelKit.AbelAdminService().addShifts(shift.localShift.AKAAddShifts).then(function (data) {
                                _this7.canvas.shifts[_i] = new _Shift2.default(data.shiftResponses[0].shift);
                                _this7.canvas.render();

                                alert.alert('close');
                                _this7.syncShifts(); //TODO: ugly and remove once backen support adding multiple shifts
                            }).catch(function (error) {
                                _this7.canvas.shifts[_i].type = 'local';
                                alert.alert('close');
                                _this7.canvas.render();
                                $.bootstrapGrowl(error.message, { 'delay': 2000, 'type': 'danger' });
                            });
                        }).catch(function (error) {
                            alert.alert('close');
                            _this7.canvas.render();
                            $.bootstrapGrowl(error.message, { 'delay': 2000, 'type': 'danger' });
                        });
                    } else {
                        //Add only
                        var _alert = $.bootstrapGrowl('Saving...');
                        _this7.abelKit.AbelAdminService().addShifts(shift.localShift.AKAAddShifts).then(function (data) {
                            _this7.canvas.shifts[_i] = new _Shift2.default(data.shiftResponses[0].shift);
                            _this7.canvas.render();
                            _alert.alert('close');
                            _this7.syncShifts(); //TODO: ugly and remove once backen support adding multiple shifts
                        }).catch(function (error) {
                            _alert.alert('close');
                            _this7.canvas.render();
                            $.bootstrapGrowl(error.message, { 'delay': 2000, 'type': 'danger' });
                        });
                    }
                    return 'break'; //TODO: ugly and remove once backend support adding multiple shifts
                }
            };

            for (var _i = this.canvas.shifts.length - 1; _i >= 0; _i--) {
                var _ret2 = _loop2(_i);

                if (_ret2 === 'break') break;
            }
        }

        /**
        * Update the local shift cache, assuming that the server shift is newer than the local shift
        *
        * @param {AKShift} serverShift
        * @param {Shift} localSchedulerShift - The shift from which the returned serverShift was derived
        */

    }, {
        key: 'processUpdatedServerShift',
        value: function processUpdatedServerShift(serverShift, localSchedulerShift) {
            //Check if present
            var i = this.canvas.shifts.findIndex(function (l) {
                return l.type != 'local' && l.serverShift.shiftId == serverShift.shiftId;
            });

            var schedulerShift = new _Shift2.default(serverShift);
            var sameShift = false;
            if (i != -1) {
                //Present, update
                this.canvas.shifts[i] = schedulerShift;
                if (localSchedulerShift.type != 'local' && localSchedulerShift.serverShift.shiftId == serverShift.shiftId) {
                    sameShift = true;
                }
            } else {
                //Not present, add
                this.canvas.shifts.push(schedulerShift);
            }

            if (!sameShift && localSchedulerShift.type == 'local') {
                //Remove localSchedulerShift
                this.canvas.shifts = this.canvas.shifts.filter(function (l) {
                    return !(l.type == 'local' && l.localShift.shiftId == localSchedulerShift.localShift.shiftId);
                });
            } else if (!sameShift) {
                //Reset localSchedulerShift
                this.canvas.shifts = this.canvas.shifts.map(function (l) {
                    if (l.type != 'local' && l.localShift.shiftId == localSchedulerShift.localShift.shiftId) {
                        l.localShift = l.serverShift;
                    }
                    return l;
                });
            }
        }

        /**
         * Changes the scheduler's date and improves
         *
         * The date used to determine the day must be the client time, in order for the day calculations to work across timezones
         * However, the date used to retrieve data must be converted to the correct timezone
         *
         * @param dateStringInLocalTimezone
         * @param offsetInMinutes
         */

    }, {
        key: 'changeDate',
        value: function changeDate(dateStringInLocalTimezone) {
            var offsetInMinutes = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;


            var dateWithOffset = moment(dateStringInLocalTimezone).add(offsetInMinutes, 'minutes');
            $('#scheduler_control_time').val(dateWithOffset.format('YYYY-MM-DD'));

            var now = moment(dateStringInLocalTimezone).tz(this.abelKit._admin.get('timezone')).add(offsetInMinutes, 'minutes');
            var startOfDay = now.startOf('day').toDate();
            var endOfDay = now.endOf('day').toDate();

            this.canvas.startTime = startOfDay;
            this.canvas.endTime = endOfDay;

            this.canvas.render();
            this.importFromServer(startOfDay, endOfDay);
        }
    }, {
        key: 'resyncDay',
        value: function resyncDay() {
            this.importFromServer(this.canvas.startTime, this.canvas.endTime);
        }
    }, {
        key: 'setToToday',
        value: function setToToday() {
            this.changeDate([]);
        }
    }, {
        key: 'setToPreviousDay',
        value: function setToPreviousDay() {
            this.changeDate($('#scheduler_control_time').val(), -60 * 24);
        }
    }, {
        key: 'setToNextDay',
        value: function setToNextDay() {
            this.changeDate($('#scheduler_control_time').val(), 60 * 24);
        }
    }, {
        key: 'attachListeners',
        value: function attachListeners() {
            var _this8 = this;

            $('#scheduler_control_time').change(function () {
                _this8.changeDate($('#scheduler_control_time').val());
                return false;
            });

            $('#scheduler_upload_item_form').submit(function () {
                return _this8.submitFile(_this8.abelKit);
            });
        }
    }, {
        key: 'submitFile',
        value: function submitFile(abelKit) {
            var file = $('#scheduler_upload_file')[0].files[0];
            var uploader = new _Uploader2.default(file, this.canvas);
            abelKit.AbelAdminService().getVehicles().then(function (data) {
                uploader.parse(data.vehicles).then(function () {
                    $('#scheduler_upload_modal').modal('hide');
                    $('#scheduler_upload_file').val('');
                    $.bootstrapGrowl('Shifts added locally. After inspection, press save to send them to the server.', {
                        'delay': 2000,
                        'type': 'success'
                    });
                }).catch(function (error) {
                    $.bootstrapGrowl(error, { 'delay': 5000, 'type': 'danger' });
                    $('#scheduler_upload_file').val('');
                });
                return false;
            });
        }
    }]);

    return SchedulerController;
}(_BaseController3.default);

exports.default = SchedulerController;

},{"./BaseController":3,"./Scheduler/Canvas":15,"./Scheduler/Modal":16,"./Scheduler/Shift":17,"./Scheduler/Uploader":20}],15:[function(require,module,exports){
"use strict";

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

var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();

var _d = require("d3");

var d3 = _interopRequireWildcard(_d);

var _Shift = require("./Shift");

var _Shift2 = _interopRequireDefault(_Shift);

var _ShiftRenderer = require("./ShiftRenderer");

var _ShiftRenderer2 = _interopRequireDefault(_ShiftRenderer);

var _StatisticsRenderer = require("./StatisticsRenderer");

var _StatisticsRenderer2 = _interopRequireDefault(_StatisticsRenderer);

var _abelkitJs = require("abelkit-js");

var AbelKitWebAdmin = _interopRequireWildcard(_abelkitJs);

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

function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

var Canvas = function () {
    /*
     */
    function Canvas(selector, heightExMargin, startTime, endTime, showModalCallback, removeShiftCallback, defaultVehicleType) {
        var _this2 = this;

        _classCallCheck(this, Canvas);

        this.margin = { top: 20, right: 20, bottom: 20, left: 40, between: 20 };
        this.startTime = startTime;
        this.endTime = endTime;
        this.showModalCallback = showModalCallback;
        this.removeShiftCallback = removeShiftCallback;
        this.localShifts = 0;
        this.defaultVehicleType = defaultVehicleType;
        this.heighExMarginShareForStatistics = 0.2;

        this.svg = d3.select(selector).append("div").attr("class", "d3-container").selectAll("svg").data(d3.range(1)).enter().append("svg").attr("id", "viz").attr("width", d3.select(selector).node().getBoundingClientRect().width).attr("height", heightExMargin + this.margin.top + this.margin.bottom);

        //statisticsGroup: a transform that shifts the axes and shift chart area corresponding to the margin
        this.statisticsGroup = this.svg.append("g").attr("transform", "translate(" + this.margin.left + "," + this.margin.top + ")");

        //shiftGroup: a transform that shifts the axes and shift chart area corresponding to the margin
        var verticalShift = this.margin.top + this.heightForStatistics + this.margin.between;
        this.shiftGroup = this.svg.append("g").attr("transform", "translate(" + this.margin.left + "," + verticalShift + ")");

        //statisticsChart: area for plotting the statistics bars
        this.statisticsChart = this.statisticsGroup.append("g").attr("class", "chart");

        //shiftChart: area for plotting the shifts
        this.shiftChart = this.shiftGroup.append("g").attr("class", "chart");

        var _this = this;

        //Background to chart area to catch clicks
        this.shiftChart.append("rect").attr("x", 0).attr("y", 0).attr("width", this.widthExMargin).attr("height", this.heightForShifts).attr("class", "aks-invisible").on("click", function () {
            if (d3.event.altKey) {
                var pos = d3.mouse(this);
                var startTime = _this.xScale.invert(_this.xScaleSnapped(pos[0]));
                _this.localShifts++;
                var newShift = new _Shift2.default(new AbelKitWebAdmin.Objects.AKShift({
                    shiftId: _this.localShifts,
                    vehicle: {
                        licensePlate: "",
                        vehicleType: _this.defaultVehicleType.typeId
                    },
                    startLocation: {
                        locationType: "gpscoord",
                        coordinate: { x: "", y: "" }, //TODO: get default for contract
                        geoType: "wgs84"
                    },
                    endLocation: {
                        locationType: "gpscoord",
                        coordinate: { x: "", y: "" }, //TODO: get default for contract
                        geoType: "wgs84"
                    },
                    startTime: startTime.toISOString(),
                    endTime: d3.timeHour.offset(startTime, 5).toISOString(),
                    state: "inactive"
                }), "local");

                _this.shifts.push(newShift);
                _this.render();
            }
        });

        //A clippath to hide the overflow of shift bars left and right
        this.shiftChart.append("defs").append("clipPath").attr("id", "clip").append("rect").attr("width", this.widthExMargin).attr("height", this.heightForShifts);

        //Axes
        this.xAxis = this.shiftGroup.append("g").attr("class", "axis").attr("transform", "translate(" + 0 + ", " + this.heightForShifts + ")");

        //Y-axis only for shifts
        /*this.yAxis = this.shiftGroup.append('g')
        .attr('class', 'axis');*/

        this.statisticsXAxis = this.statisticsGroup.append("g").attr("class", "axis").attr("transform", "translate(" + 0 + ", " + this.heightForStatistics + ")");

        this.statisticsRenderer = new _StatisticsRenderer2.default(this);

        this.shiftRenderer = new _ShiftRenderer2.default(this, function () {
            _this2.statisticsRenderer.render(true);
        });

        this.shifts = [];
        this.statistics = [];
    }

    _createClass(Canvas, [{
        key: "xScaleSnapped",


        /*
            Provide the x-position and return the closest snapped x-position
        */
        value: function xScaleSnapped(x) {
            var timestamp = this.xScale.invert(x);
            var coeff = 1000 * 60 * 15; //15 minute
            var rounded = new Date(Math.round(timestamp.getTime() / coeff) * coeff);
            return this.xScale(rounded);
        }
    }, {
        key: "updateAxes",
        value: function updateAxes() {
            var xAxis = d3.axisBottom().scale(this.xScale).tickFormat(d3.timeFormat("%H:%M"));
            this.xAxis.call(xAxis);

            var statisticsXAxis = d3.axisBottom().scale(this.xScale).tickFormat(d3.timeFormat("%H:%M"));
            this.statisticsXAxis.call(statisticsXAxis);

            /*var yAxis = d3.axisLeft()
            .scale(this.yScaleForShifts);
            this.yAxis.call(yAxis);*/
        }
    }, {
        key: "render",
        value: function render() {
            var animate = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;

            this.statisticsRenderer.render(animate);
            this.shiftRenderer.render(animate);
            this.updateAxes();
        }
    }, {
        key: "widthExMargin",
        get: function get() {
            return parseFloat(d3.select(this.svg.node()).attr("width")) - this.margin.left - this.margin.right;
        },
        set: function set(widthExMargin) {
            d3.select(this.svg.node()).attr("width", widthExMargin + this.margin.left + this.margin.right);
        }
    }, {
        key: "heightExMargin",
        get: function get() {
            return parseFloat(d3.select(this.svg.node()).attr("height")) - this.margin.top - this.margin.bottom;
        },
        set: function set(heightExMargin) {
            d3.select(this.svg.node()).attr("height", heightExMargin + this.margin.top + this.margin.bottom);
        }
    }, {
        key: "heightForStatistics",
        get: function get() {
            return Math.floor(this.heighExMarginShareForStatistics * this.heightExMargin);
        }
    }, {
        key: "heightForShifts",
        get: function get() {
            return this.heightExMargin - this.heightForStatistics - this.margin.between;
        }
    }, {
        key: "xScale",
        get: function get() {
            return d3.scaleTime().domain([this.startTime, this.endTime]).range([0, this.widthExMargin]);
        }
    }, {
        key: "yScaleForShifts",
        get: function get() {
            var maxDomain = 0;
            if (this.shifts.length > 0) {
                maxDomain = d3.max(this.shifts, function (d) {
                    return d.level;
                });
            }

            return d3.scaleLinear().domain([0, Math.max(maxDomain + 1, 10)]) //Always leave room to draw one more shift and show at least 10
            .range([this.heightForShifts, 0]);
        }
    }, {
        key: "yScaleForStatistics",
        get: function get() {
            var maxDomain = 0;
            if (this.statistics.length > 0) {
                maxDomain = d3.max(this.statistics, function (d) {
                    return Math.max(d.expectedSeatUtilization, d.targetSeatUtilizationUpperBound);
                });
            }
            return d3.scaleLinear().domain([0, maxDomain]).range([this.heightForStatistics, 0]);
        }
    }]);

    return Canvas;
}();

exports.default = Canvas;

},{"./Shift":17,"./ShiftRenderer":18,"./StatisticsRenderer":19,"abelkit-js":"abelkit-js","d3":"d3"}],16:[function(require,module,exports){
"use strict";

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

var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); /*global $, Templates */


var _abelkitJs = require("abelkit-js");

var AbelKitWebAdmin = _interopRequireWildcard(_abelkitJs);

var _Autocomplete = require("./../Autocomplete/Autocomplete");

var _Autocomplete2 = _interopRequireDefault(_Autocomplete);

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

function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

var Modal = function () {
    function Modal(shift, mapBoundingBox, vehicleTypes, modalClosedCallback, abelKit) {
        var _this2 = this;

        _classCallCheck(this, Modal);

        //this.shift = shift;
        this.mapBoundingBox = mapBoundingBox;
        this.abelKit = abelKit;
        this.vehicleTypes = vehicleTypes;
        this.shift = shift;

        //Load modal into content_container

        shift.localShift.vehicle.vehicleTypeName = this.vehicleTypes.find(function (v) {
            return v.typeId == shift.localShift.vehicle.vehicleType;
        }).name;
        $("#scheduler_modal_container").html(Templates["scheduler_modal"](shift));

        if ($("#scheduler_modal_start").val() === ", ") {
            $("#scheduler_modal_start").val("");
        }

        if ($("#scheduler_modal_end").val() === ", ") {
            $("#scheduler_modal_end").val("");
        }

        $("#scheduler_modal").modal();
        $("#scheduler_modal").on("hide.bs.modal", function () {
            modalClosedCallback();
        });

        var placeSelectionCallback = function placeSelectionCallback(evt, suggestion) {
            var id = void 0;
            if (!evt.target) {
                id = evt.split("#").length === 2 ? evt.split("#")[1] : evt;
            } else {
                id = evt.target.id;
            }

            var which = id == "scheduler_modal_start" ? "start" : "end";
            _this2.shift.localShift[which + "Location"] = suggestion.location;

            $("#scheduler_modal_" + which).val(suggestion.location.POIName);

            $("#scheduler_modal_" + which).data("oldVal", $("#scheduler_modal_" + which).val());
            $("#scheduler_modal_" + which).parent().parents(".form-group").removeClass("has-error").addClass("has-success");
        };

        this.autocomplete = new _Autocomplete2.default(abelKit, ["#scheduler_modal_start", "#scheduler_modal_end"], placeSelectionCallback, false, true);

        this.attachListeners();
    }

    _createClass(Modal, [{
        key: "attachListeners",
        value: function attachListeners() {
            this.attachLocationListener();
            this.attachDriverListener();
            this.attachVehicleListener();
        }
    }, {
        key: "attachLocationListener",
        value: function attachLocationListener() {
            this.attachInputListener($("#scheduler_modal_start"));

            this.attachInputListener($("#scheduler_modal_end"));

            $("#scheduler_modal_start, #scheduler_modal_end").focus(function (evt) {
                var which = evt.target.id == "scheduler_modal_start" ? "start" : "end";
                $("#scheduler_modal_" + which).select();
            });
        }
    }, {
        key: "attachDriverListener",
        value: function attachDriverListener() {
            var _this3 = this;

            var _this = this;
            var timeOut = null;

            var scheduler_modal_driver_typeahead = function findMatches(query, syncResults, asyncResults) {
                if (timeOut != null) clearTimeout(timeOut);
                timeOut = setTimeout(queryAutocomplete, 200);

                function queryAutocomplete() {
                    _this.abelKit.AbelAdminService().getDrivers(query).then(function (response) {
                        asyncResults(response.drivers);
                    }).catch(function (error) {
                        $.bootstrapGrowl(error.message, {
                            delay: 2000,
                            type: "danger"
                        });
                    });
                }
            };

            var element = $("#scheduler_modal_driver");

            element.typeahead(null, {
                name: "autocomplete",
                displayKey: "name",
                source: scheduler_modal_driver_typeahead,
                limit: 10,
                templates: {
                    suggestion: function suggestion(data) {
                        return "<div><strong>" + data.name + "</strong></div>";
                    }
                }
            });

            element.focus(function () {
                element.select();
            });

            this.attachInputListener(element, function (newVal) {
                if (newVal == "") delete _this3.shift.localShift.driver;
            }, true);

            element.bind("typeahead:selected typeahead:autocomplete", function (evt, suggestion) {
                _this3.shift.localShift.driver = suggestion;
                element.data("oldVal", element.val());
                element.parents(".form-group").removeClass("has-error").addClass("has-success");
            });
        }
    }, {
        key: "attachVehicleListener",
        value: function attachVehicleListener() {
            var _this4 = this;

            var _this = this;

            var licensePlateElement = $("#scheduler_modal_license_plate");
            var vehicleTypeElement = $("#scheduler_modal_vehicle_type_name");

            $('input[name="scheduler_modal_vehicle_radios"]').change(function () {
                if ($("#scheduler_modal_vehicle_radio_type").prop("checked")) {
                    licensePlateElement.val("");
                    vehicleTypeElement.parents(".form-group").addClass("has-error").removeClass("has-success");
                    licensePlateElement.parents(".form-group").removeClass("has-error").removeClass("has-success");
                } else {
                    vehicleTypeElement.val("");
                    licensePlateElement.parents(".form-group").addClass("has-error").removeClass("has-success");
                    vehicleTypeElement.parents(".form-group").removeClass("has-error").removeClass("has-success");
                }
            });

            //License plate async typeahead
            var timeOut = null;
            var scheduler_modal_license_plate_typeahead = function findMatches(query, syncResults, asyncResults) {
                if (timeOut != null) clearTimeout(timeOut);
                timeOut = setTimeout(queryAutocomplete, 200);

                function queryAutocomplete() {
                    _this.abelKit.AbelAdminService().getVehicles(query).then(function (response) {
                        asyncResults(response.vehicles);
                    }).catch(function (error) {
                        $.bootstrapGrowl(error.message, {
                            delay: 2000,
                            type: "danger"
                        });
                    });
                }
            };

            licensePlateElement.typeahead(null, {
                name: "autocomplete",
                displayKey: "licensePlate",
                source: scheduler_modal_license_plate_typeahead,
                limit: 10,
                templates: {
                    suggestion: function suggestion(data) {
                        return "<div><strong>" + data.licensePlate + "</strong></div>";
                    }
                }
            });

            licensePlateElement.focus(function () {
                licensePlateElement.select();
            });

            this.attachInputListener(licensePlateElement, function () {}, false, [vehicleTypeElement]);

            licensePlateElement.bind("typeahead:selected typeahead:autocomplete", function (evt, suggestion) {
                licensePlateElement.parents(".form-group").find(":radio").prop("checked", true);
                $('input[name="scheduler_modal_vehicle_radios"]').trigger("change");
                _this4.shift.localShift.vehicle = suggestion;
                licensePlateElement.data("oldVal", licensePlateElement.val());
                licensePlateElement.parents(".form-group").removeClass("has-error").addClass("has-success");
            });

            //Vehicle type sync typeahead
            var scheduler_modal_vehicle_type_typeahead = function findMatches(query, syncResults) {
                var eligibleVehicleTypes = _this.vehicleTypes.filter(function (v) {
                    return v.name.toLowerCase().includes(query.toLowerCase());
                });
                syncResults(eligibleVehicleTypes);
            };

            vehicleTypeElement.typeahead(null, {
                name: "autocomplete",
                displayKey: "name",
                source: scheduler_modal_vehicle_type_typeahead,
                limit: 10,
                templates: {
                    suggestion: function suggestion(data) {
                        return "<div><strong>" + data.name + "</strong></div>";
                    }
                }
            });

            vehicleTypeElement.focus(function () {
                vehicleTypeElement.select();
            });

            this.attachInputListener(vehicleTypeElement, function () {}, false, [licensePlateElement]);

            vehicleTypeElement.bind("typeahead:selected typeahead:autocomplete", function (evt, suggestion) {
                vehicleTypeElement.parents(".form-group").find(":radio").prop("checked", true);
                $('input[name="scheduler_modal_vehicle_radios"]').trigger("change");
                _this4.shift.localShift.vehicle = new AbelKitWebAdmin.Objects.AKVehicle({
                    licensePlate: "",
                    vehicleType: suggestion.typeId
                });
                vehicleTypeElement.data("oldVal", vehicleTypeElement.val());
                vehicleTypeElement.parents(".form-group").removeClass("has-error").addClass("has-success");
            });
        }
    }, {
        key: "attachInputListener",
        value: function attachInputListener(element) {
            var clearUnderlyingObjectFunction = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : function () {};
            var optionalElement = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
            var otherElementsInRadio = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : [];

            element.data("oldVal", element.val());
            element.bind("propertychange change click keyup input paste", function () {
                if (element.data("oldVal") != element.val()) {
                    //console.log('Input listener for '+ element.attr('id')+ ' triggered: oldVal ' + element.data('oldVal') +', newVal: ' + element.val());
                    element.data("oldVal", element.val());

                    //Check radio, if somewhere in parent
                    element.parents(".form-group").find(":radio").prop("checked", true);

                    //Clear underlying element(s)
                    clearUnderlyingObjectFunction(element.val());

                    //Set validation of element itself: assume it's not valid and that it will be validated by the typeahead:autocomplete
                    if (element.val() != "" || !optionalElement) {
                        element.parents(".form-group").addClass("has-error").removeClass("has-success");
                    } else {
                        element.parents(".form-group").removeClass("has-error").removeClass("has-success");
                    }

                    //Clear validation of other elements in radio
                    var _iteratorNormalCompletion = true;
                    var _didIteratorError = false;
                    var _iteratorError = undefined;

                    try {
                        for (var _iterator = otherElementsInRadio[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
                            var otherElement = _step.value;

                            otherElement.parents(".form-group").removeClass("has-error").removeClass("has-success");
                            otherElement.val("");
                        }
                    } catch (err) {
                        _didIteratorError = true;
                        _iteratorError = err;
                    } finally {
                        try {
                            if (!_iteratorNormalCompletion && _iterator.return) {
                                _iterator.return();
                            }
                        } finally {
                            if (_didIteratorError) {
                                throw _iteratorError;
                            }
                        }
                    }
                }
            });
        }
    }, {
        key: "checkValues",
        value: function checkValues() {
            if ($("#scheduler_modal_vehicle_radio_type").prop("checked")) {
                if ($("#scheduler_modal_vehicle_type_form_group").hasClass("has-error")) return false;
            } else {
                if ($("#scheduler_modal_license_plate_form_group").hasClass("has-error")) return false;
            }

            if ($("#scheduler_modal_driver_form_group").hasClass("has-error")) return false;
            if ($("#scheduler_modal_start").parent().hasClass("has-error")) return false;
            if ($("#scheduler_modal_end").parent().hasClass("has-error")) return false;

            return true;
        }
    }, {
        key: "resetShift",
        value: function resetShift() {
            if (this.shift.serverShift != null) {
                this.shift.localShift.driver = new AbelKitWebAdmin.Objects.AKDriver(this.shift.serverShift.driver);
                this.shift.localShift.vehicle = new AbelKitWebAdmin.Objects.AKVehicle(this.shift.serverShift.vehicle);
                this.shift.localShift.startLocation = new AbelKitWebAdmin.Objects.AKLocationBase(this.shift.serverShift.startLocation);
                this.shift.localShift.endLocation = new AbelKitWebAdmin.Objects.AKLocationBase(this.shift.serverShift.endLocation);
            }
        }
    }, {
        key: "hide",
        value: function hide() {
            $("#scheduler_modal").modal("hide");
        }
    }]);

    return Modal;
}();

exports.default = Modal;

},{"./../Autocomplete/Autocomplete":2,"abelkit-js":"abelkit-js"}],17:[function(require,module,exports){
'use strict';

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

var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();

var _abelkitJs = require('abelkit-js');

var AbelKitWebAdmin = _interopRequireWildcard(_abelkitJs);

function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

var Shift = function () {
    function Shift(shift) {
        var type = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 'committed';

        _classCallCheck(this, Shift);

        if (type != 'local') {
            this.serverShift = new AbelKitWebAdmin.Objects.AKShift(shift);
        } else {
            this.serverShift = null;
        }
        this.localShift = new AbelKitWebAdmin.Objects.AKShift(shift);

        /*var allowedTypes = [
            'actual',
            'committed', //shift is taken into account when deciding whether to accept incoming trips
            'uncommitted', //shift is not taken into account when deciding whether to accept incoming trips, but shift is open for drivers to sign up for
            'local' //shift has not been synced with server yet
        ];*/

        this.type = type;
        this.level = 1;
    }

    _createClass(Shift, [{
        key: 'status',
        value: function status() {
            if (this.equal()) {
                return this.serverShift.state.value;
            }
            return 'unsynced';
        }
    }, {
        key: 'equal',
        value: function equal() {
            return this.type != 'local' && this.localShift.equal(this.serverShift);
        }
    }, {
        key: 'reset',
        value: function reset() {
            if (this.type != 'local') {
                this.localShift = new AbelKitWebAdmin.Objects.AKShift(this.serverShift);
            }
        }
    }]);

    return Shift;
}();

exports.default = Shift;

},{"abelkit-js":"abelkit-js"}],18:[function(require,module,exports){
'use strict';

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

var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();

var _d = require('d3');

var d3 = _interopRequireWildcard(_d);

var _d3Tip = require('d3-tip');

var _d3Tip2 = _interopRequireDefault(_d3Tip);

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

function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

var ShiftRenderer = function () {
    function ShiftRenderer(canvas, statisticsUpdateCallback) {
        _classCallCheck(this, ShiftRenderer);

        this.canvas = canvas;
        this.transitionDuration = 500;
        this.dragBarWidth = 6;
        this.minShiftIntervalMinutes = 30;
        this.maxShiftIntervalMinutes = 16 * 60;
        this.verticalPadding = 0.05;
        this.textPadding = 8;
        this.statisticsUpdateCallback = statisticsUpdateCallback;

        var formatTime = d3.timeFormat('%H:%M');
        this.shiftTimesTip = (0, _d3Tip2.default)().attr('class', 'd3-tip').offset([-10, 0]).html(function (d) {
            return '<p>' + formatTime(d.localShift.startTime) + ' - ' + formatTime(d.localShift.endTime) + '</p>';
        });

        /* Invoke the tip in the context of your visualization */
        this.canvas.shiftChart.call(this.shiftTimesTip);
    }

    _createClass(ShiftRenderer, [{
        key: 'render',
        value: function render() {
            var animate = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;

            //Order shifts
            this.orderShifts();

            //Plot shifts
            var bars = this.canvas.shiftChart.selectAll('g.barGroup').data(this.canvas.shifts, function (d) {
                return d.type + d.localShift.shiftId;
            } //Determines id of each element
            ); //See https://bost.ocks.org/mike/join/

            //New shifts: blocks
            var newBars = bars.enter().append('g').attr('class', 'barGroup');
            this.addContentsToBarGroups(newBars);

            //Existing shifts: animate to new position
            this.layOutBarGroups(bars, animate);

            //Removed shifts
            this.removeBarGroups(bars.exit(), animate);
        }
    }, {
        key: 'orderShifts',
        value: function orderShifts() {
            this.canvas.shifts.sort(function (a, b) {
                /*
                Order on shiftTime descending.
                Note: If compareFunction(a, b) is less than 0, sort a to a lower index than b, i.e. a comes first.
                */
                if (b.localShift.shiftTime - a.localShift.shiftTime != 0) {
                    return b.localShift.shiftTime - a.localShift.shiftTime;
                }
                return b.localShift.shiftId - a.localShift.shiftId;
            });

            var maxLevel = 1;
            for (var i = 0; i < this.canvas.shifts.length; i++) {
                //Generate array of available levels
                var availableLevels = [];
                for (var j = 1; j <= maxLevel + 1; j++) {
                    availableLevels.push(j);
                }

                //Loop through shifts before this shifts and remove elements from available levels that are alredy taken
                for (var k = 0; k < i; k++) {
                    if (this.canvas.shifts[k].localShift.startTime < this.canvas.shifts[i].localShift.endTime && this.canvas.shifts[k].localShift.endTime > this.canvas.shifts[i].localShift.startTime) {
                        //There is overlap
                        var index = availableLevels.indexOf(this.canvas.shifts[k].level);
                        if (index > -1) {
                            availableLevels.splice(index, 1);
                        }
                    }
                }

                this.canvas.shifts[i].level = Math.min.apply(null, availableLevels);
                maxLevel = Math.max(maxLevel, this.canvas.shifts[i].level);
            }
        }
    }, {
        key: 'addContentsToBarGroups',
        value: function addContentsToBarGroups(barGroups) {
            var _this2 = this;

            barGroups.append('rect').attr('class', 'bar').attr('clip-path', 'url(#clip)').attr('rx', 1).attr('ry', 1).on('click', function (d) {
                if (d3.event.altKey) {
                    _this.canvas.removeShiftCallback(d, function () {
                        _this.canvas.shifts = _this.canvas.shifts.filter(function (l) {
                            return !(l.localShift.shiftId == d.localShift.shiftId && l.type == d.type);
                        });
                        _this.canvas.render();
                    });
                } else {
                    //Show settings
                    //let shift = _this.canvas.shifts.find((v) => v.localShift.shiftId == d.localShift.shiftId && v.type == d.type);
                    _this.canvas.showModalCallback(d);
                }
            }).on('mouseover', function (d) {
                _this.shiftTimesTip.show(d, this);
            }).on('mouseout', this.shiftTimesTip.hide).call(d3.drag().subject(function () {
                //To ensure dragging aligns mouse position in object with dragging of object
                var t = d3.select(this);
                return { x: t.attr('x'), y: t.attr('y') };
            }).on('start', function (d) {
                //d3.select(this.parentNode).selectAll('text.label').text('');
                _this.shiftTimesTip.show(d, this);
            }).on('drag', function (d) {
                var snappedCursorX = _this.canvas.xScaleSnapped(d3.event.x);
                var intervalMilliSeconds = d.localShift.shiftTime;
                d.localShift.startTime = _this.canvas.xScale.invert(snappedCursorX); //Cursor position
                d.localShift.endTime = d3.timeMillisecond.offset(d.localShift.startTime, intervalMilliSeconds);
                _this.render(false);
                _this.shiftTimesTip.show(d, this);
            }).on('end', function (d) {
                //This is also triggered on click. Only make changes if really dragged
                if (Math.abs(d3.event.dx) > 0) {
                    var snappedCursorX = _this.canvas.xScaleSnapped(d3.event.x);
                    var intervalMilliSeconds = d.localShift.shiftTime;
                    d.localShift.startTime = _this2.canvas.xScale.invert(snappedCursorX); //Cursor position
                    d.localShift.endTime = d3.timeMillisecond.offset(d.localShift.startTime, intervalMilliSeconds);
                    _this2.render(true);
                    _this2.statisticsUpdateCallback();
                    _this2.shiftTimesTip.hide(d);
                }
            }));

            var _this = this;
            barGroups.append('rect').attr('class', 'bar-handle left').attr('width', this.dragBarWidth).attr('clip-path', 'url(#clip)').on('mouseover', function (d) {
                _this.shiftTimesTip.show(d, this);
            }).on('mouseout', this.shiftTimesTip.hide).call(d3.drag().subject(function () {
                //To ensure dragging aligns mouse position in object with dragging of object
                var t = d3.select(this);
                return { x: t.attr('x'), y: t.attr('y') };
            }).on('start', function (d) {
                _this.shiftTimesTip.show(d, this);
            }).on('drag', function (d) {
                var snappedCursorX = _this.canvas.xScaleSnapped(d3.event.x);
                d.localShift.startTime = new Date(Math.max(Math.min(_this.canvas.xScale.invert(snappedCursorX), //Cursor position
                d3.timeMinute.offset(d.localShift.endTime, -1 * _this.minShiftIntervalMinutes) //Ensuring shift will be at least as long as minimum shift length
                ), d3.timeMinute.offset(d.localShift.endTime, -1 * _this.maxShiftIntervalMinutes) //Ensuring shift will be at most as long as maximum shift length
                ));
                _this.render(false);
                _this.shiftTimesTip.show(d, this);
            }).on('end', function (d) {
                var snappedCursorX = _this.canvas.xScaleSnapped(d3.event.x);
                d.localShift.startTime = new Date(Math.max(Math.min(_this2.canvas.xScale.invert(snappedCursorX), //Cursor position
                d3.timeMinute.offset(d.localShift.endTime, -1 * _this2.minShiftIntervalMinutes) //Ensuring shift will be at least as long as minimum shift length
                ), d3.timeMinute.offset(d.localShift.endTime, -1 * _this2.maxShiftIntervalMinutes) //Ensuring shift will be at most as long as maximum shift length
                ));
                _this2.render(true);
                _this2.statisticsUpdateCallback();
                _this2.shiftTimesTip.hide(d);
            }));

            barGroups.append('rect').attr('class', 'bar-handle right').attr('width', this.dragBarWidth).attr('clip-path', 'url(#clip)').on('mouseover', function (d) {
                _this.shiftTimesTip.show(d, this);
            }).on('mouseout', this.shiftTimesTip.hide).call(d3.drag().subject(function () {
                //To ensure dragging aligns mouse position in object with dragging of object
                var t = d3.select(this);
                return { x: t.attr('x'), y: t.attr('y') };
            }).on('start', function (d) {
                _this.shiftTimesTip.show(d, this);
            }).on('drag', function (d) {
                var snappedCursorX = _this.canvas.xScaleSnapped(d3.event.x);
                d.localShift.endTime = new Date(Math.min(Math.max(_this.canvas.xScale.invert(snappedCursorX), //Cursor position
                d3.timeMinute.offset(d.localShift.startTime, _this.minShiftIntervalMinutes) //Ensuring shift will be at least as long as minimum shift length
                ), d3.timeMinute.offset(d.localShift.startTime, _this.maxShiftIntervalMinutes) //Ensuring shift will be at most as long as maximum shift length
                ));
                _this.render(false);
                _this.shiftTimesTip.show(d, this);
            }).on('end', function (d) {
                var snappedCursorX = _this.canvas.xScaleSnapped(d3.event.x);
                d.localShift.endTime = new Date(Math.min(Math.max(_this2.canvas.xScale.invert(snappedCursorX), //Cursor position
                d3.timeMinute.offset(d.localShift.startTime, _this2.minShiftIntervalMinutes) //Ensuring shift will be at least as long as minimum shift length
                ), d3.timeMinute.offset(d.localShift.startTime, _this2.maxShiftIntervalMinutes) //Ensuring shift will be at most as long as maximum shift length
                ));
                _this2.render(true);
                _this2.statisticsUpdateCallback();
                _this2.shiftTimesTip.hide(d);
            }));

            barGroups.append('text').attr('clip-path', 'url(#clip)').attr('class', 'label').attr('dy', '.35em'); //vertical align middle

            this.layOutBarGroups(barGroups, false);
        }
    }, {
        key: 'layOutBarGroups',
        value: function layOutBarGroups(barGroups) {
            var _this3 = this;

            var animate = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;

            var _this = this;

            var x = function x(d) {
                //https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions/Arrow_functions
                return _this3.canvas.xScale(d.localShift.startTime);
            };

            var y = function y(d) {
                //https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions/Arrow_functions
                return _this3.canvas.yScaleForShifts(d.level) + _this3.verticalPadding;
            };

            var textY = function textY(d) {
                return y(d) + _this3.canvas.yScaleForShifts(0) - _this3.canvas.yScaleForShifts((1 - 2 * _this3.verticalPadding) / 2);
            };

            var width = function width(d) {
                var hstart = d.localShift.startTime;
                var hstop = d.localShift.endTime;
                return _this3.canvas.xScale(hstop) - _this3.canvas.xScale(hstart);
            };

            var text = function text(d) {
                if (d.localShift.driver != undefined) {
                    return d.localShift.driver.name;
                }
                return 'To be determined';
            };

            var wrapText = function wrapText(element, width, padding) {
                var self = d3.select(element),
                    textLength = self.node().getComputedTextLength(),
                    text = self.text();
                while (textLength > width - 2 * padding && text.length > 0) {
                    text = text.slice(0, -1);
                    self.text(text + '...');
                    textLength = self.node().getComputedTextLength();
                }
            };

            var bars = barGroups.selectAll('rect.bar');
            var barHandlesLeft = barGroups.selectAll('rect.bar-handle.left');
            var barHandlesRight = barGroups.selectAll('rect.bar-handle.right');
            var barText = barGroups.selectAll('text.label');
            var barTextTimeout = 0;
            var barTextTransition = barText;
            if (animate) {
                bars = bars.transition().duration(this.transitionDuration);
                barHandlesLeft = barHandlesLeft.transition().duration(this.transitionDuration);
                barHandlesRight = barHandlesRight.transition().duration(this.transitionDuration);
                barText.each(function (d) {
                    var element = d3.select(this);
                    if (Math.abs(parseFloat(element.attr('y')) - textY(d)) > 0.001) {
                        element.text('');
                    }
                });
                barTextTransition = barText.transition().duration(this.transitionDuration);
            }

            bars.attr('class', function (d) {
                var cssStatus = d.status().replace(/([A-Z])/g, function (g) {
                    return '-' + g[0].toLowerCase();
                }); //Convert to CSS case
                return 'bar ' + cssStatus;
            }).attr('y', y).attr('x', x).attr('width', width).attr('height', function () {
                return _this3.canvas.yScaleForShifts(0) - _this3.canvas.yScaleForShifts(1 - 2 * _this3.verticalPadding);
            });

            barHandlesLeft.attr('x', function (d) {
                return x(d) - _this3.dragBarWidth / 2;
            }).attr('y', y).attr('height', function () {
                return _this3.canvas.yScaleForShifts(0) - _this3.canvas.yScaleForShifts(1 - 2 * _this3.verticalPadding);
            });

            barHandlesRight.attr('x', function (d) {
                return x(d) + width(d) - _this3.dragBarWidth / 2;
            }).attr('y', y).attr('height', function () {
                return _this3.canvas.yScaleForShifts(0) - _this3.canvas.yScaleForShifts(1 - 2 * _this3.verticalPadding);
            });

            barTextTransition.attr('x', function (d) {
                return x(d) + _this3.textPadding; //padding
            }).attr('y', textY).attr('width', width);

            d3.timeout(function () {
                barText.text(text).each(function (d) {
                    return wrapText(this, width(d), _this.textPadding);
                });
            }, barTextTimeout);
        }
    }, {
        key: 'removeBarGroups',
        value: function removeBarGroups(barGroups, animate) {
            var bars = barGroups.selectAll('rect.bar');
            var barHandles = barGroups.selectAll('rect.bar-handle');
            var barText = barGroups.selectAll('text.label');
            var _barGroups = barGroups;

            if (animate) {
                bars = bars.transition().duration(this.transitionDuration);
                _barGroups = _barGroups.transition().duration(this.transitionDuration);

                //Don't animate removal of barText and barHandlers, remove them immediately
            }

            bars.attr('width', 0);

            barHandles.remove();

            barText.remove();

            _barGroups.remove();
        }
    }]);

    return ShiftRenderer;
}();

exports.default = ShiftRenderer;

},{"d3":"d3","d3-tip":"d3-tip"}],19:[function(require,module,exports){
'use strict';

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

var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();

var _d3Tip = require('d3-tip');

var _d3Tip2 = _interopRequireDefault(_d3Tip);

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

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

var StatisticsRenderer = function () {
    function StatisticsRenderer(canvas) {
        _classCallCheck(this, StatisticsRenderer);

        this.canvas = canvas;
        this.transitionDuration = 500;
        this.horizontalPadding = 5;

        this.actualTip = (0, _d3Tip2.default)().attr('class', 'd3-tip').offset([-10, 0]).html(function (d) {
            return '<p>Booked: ' + d.bookedSeatMinutes.toFixed(0) + ' min.<br>Available: ' + d.availableSeatMinutes.toFixed(0) + ' min.<br>Current utilization: ' + d.getCurrentSeatUtilizationString() + '</p>';
        });
        this.expectedTip = (0, _d3Tip2.default)().attr('class', 'd3-tip').offset([-10, 0]).html(function (d) {
            return '<p>Expected booking: ' + d.expectationOfBookedSeatMinutesAtTimeOfPickup.toFixed(0) + ' min.<br>Available: ' + d.availableSeatMinutes.toFixed(0) + ' min.</p>';
        });

        /* Invoke the tip in the context of your visualization */
        this.canvas.statisticsChart.call(this.actualTip);
        this.canvas.statisticsChart.call(this.expectedTip);
    }

    _createClass(StatisticsRenderer, [{
        key: 'updateShiftStatistics',
        value: function updateShiftStatistics() {
            var _this = this;

            var _loop = function _loop() {
                var statistic = _this.canvas.statistics[i];
                _this.canvas.statistics[i].availableSeatMinutes = _this.canvas.shifts.reduce(function (acc, d) {
                    var startTimeWithinStatistic = Math.max(Math.min(d.localShift.startTime, statistic.endTime), statistic.startTime);

                    var endTimeWithinStatistic = Math.max(Math.min(d.localShift.endTime, statistic.endTime), statistic.startTime);

                    var minutesInStatistic = (endTimeWithinStatistic - startTimeWithinStatistic) / 60000; //Originally in milliseconds
                    return acc + minutesInStatistic;
                }, 0);
            };

            for (var i = 0; i < this.canvas.statistics.length; i++) {
                _loop();
            }
        }
    }, {
        key: 'render',
        value: function render() {
            var animate = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;

            this.updateShiftStatistics();

            //Plot statistics bars
            var bars = this.canvas.statisticsChart.selectAll('g.barGroup').data(this.canvas.statistics, function (d) {
                return d.startTime;
            } //Determines id of each element
            ); //See https://bost.ocks.org/mike/join/

            //New statistics: blocks
            var newBars = bars.enter().append('g').attr('class', 'barGroup');
            this.addContentsToBarGroups(newBars);

            //Existing statistics: animate to new position
            this.layOutBarGroups(bars, animate);

            //Removed statistics
            this.removeBarGroups(bars.exit(), animate);
        }
    }, {
        key: 'addContentsToBarGroups',
        value: function addContentsToBarGroups(barGroups) {
            barGroups.append('rect').attr('class', 'statistics-bar actual').on('mouseover', this.actualTip.show).on('mouseout', this.actualTip.hide);

            barGroups.append('rect').attr('class', 'statistics-bar expectation').on('mouseover', this.expectedTip.show).on('mouseout', this.expectedTip.hide);

            barGroups.append('text').attr('class', 'statistics-text').attr('text-anchor', 'middle');

            this.layOutBarGroups(barGroups, false);
        }
    }, {
        key: 'layOutBarGroups',
        value: function layOutBarGroups(barGroups) {
            var _this2 = this;

            var animate = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;

            var x = function x(d) {
                //https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions/Arrow_functions
                return _this2.canvas.xScale(d.startTime) + _this2.horizontalPadding;
            };

            var width = function width(d) {
                var hstart = d.startTime;
                var hstop = d.endTime;
                return _this2.canvas.xScale(hstop) - _this2.canvas.xScale(hstart);
            };

            var actualBars = barGroups.selectAll('rect.statistics-bar.actual');
            var expectationBars = barGroups.selectAll('rect.statistics-bar.expectation');
            var text = barGroups.selectAll('text.statistics-text');

            if (animate) {
                actualBars = actualBars.transition().duration(this.transitionDuration);
                expectationBars = expectationBars.transition().duration(this.transitionDuration);
                text = text.transition().duration(this.transitionDuration);
            }

            actualBars.attr('class', function (d) {
                var classes = 'statistics-bar actual';
                if (d.performance == 1) {
                    return classes + ' too-high';
                } else if (d.performance == -1) {
                    return classes + ' too-low';
                } else {
                    return classes + ' on-target';
                }
            }).attr('y', function (d) {
                //return top
                return _this2.canvas.yScaleForStatistics(d.currentSeatUtilization);
            }).attr('x', x).attr('width', function (d) {
                return Math.max(width(d) - 2 * _this2.horizontalPadding, 0);
            }).attr('height', function (d) {
                return _this2.canvas.yScaleForStatistics(0) - _this2.canvas.yScaleForStatistics(d.currentSeatUtilization);
            });

            expectationBars.attr('class', function (d) {
                var classes = 'statistics-bar expectation';
                if (d.performance == 1) {
                    return classes + ' too-high';
                } else if (d.performance == -1) {
                    return classes + ' too-low';
                } else {
                    return classes + ' on-target';
                }
            }).attr('y', function (d) {
                //return top
                return _this2.canvas.yScaleForStatistics(d.expectedSeatUtilization);
            }).attr('x', x).attr('width', function (d) {
                return Math.max(width(d) - 2 * _this2.horizontalPadding, 0);
            }).attr('height', function (d) {
                return -_this2.canvas.yScaleForStatistics(d.expectedSeatUtilization) + _this2.canvas.yScaleForStatistics(d.currentSeatUtilization);
            });

            text.attr('y', function (d) {
                //return top
                return _this2.canvas.yScaleForStatistics(d.expectedSeatUtilization) - 1;
            }).attr('x', function (d) {
                //As we've set text-anchor to middle, x should be the middle of the bar
                return (_this2.canvas.xScale(d.startTime) + _this2.canvas.xScale(d.endTime)) / 2;
            }).text(function (d) {
                return d.getExpectedSeatUtilizationPercentage(1);
            });
        }
    }, {
        key: 'removeBarGroups',
        value: function removeBarGroups(barGroups, animate) {
            var _this3 = this;

            var actualBars = barGroups.selectAll('rect.statistics-bar.actual');
            var expectationBars = barGroups.selectAll('rect.statistics-bar.expectation');

            var _barGroups = barGroups;

            if (animate) {
                //Otherwise animation wouldn't be nice
                expectationBars.attr('height', function (d) {
                    return _this3.canvas.yScaleForStatistics(d.expectedSeatUtilization);
                });

                actualBars = actualBars.transition().duration(this.transitionDuration);
                expectationBars = expectationBars.transition().duration(this.transitionDuration);
                _barGroups = _barGroups.transition().duration(this.transitionDuration);

                //Don't animate removal of barText and barHandlers, remove them immediately
            }

            actualBars.attr('height', 0);
            expectationBars.attr('height', 0);

            _barGroups.remove();
        }
    }]);

    return StatisticsRenderer;
}();

exports.default = StatisticsRenderer;

},{"d3-tip":"d3-tip"}],20:[function(require,module,exports){
'use strict';

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

var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();

var _abelkitJs = require('abelkit-js');

var AbelKitWebAdmin = _interopRequireWildcard(_abelkitJs);

var _Shift = require('./Shift');

var _Shift2 = _interopRequireDefault(_Shift);

var _papaparse = require('papaparse');

var _papaparse2 = _interopRequireDefault(_papaparse);

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

function _interopRequireWildcard(obj) { if (obj && obj.__esModule) { return obj; } else { var newObj = {}; if (obj != null) { for (var key in obj) { if (Object.prototype.hasOwnProperty.call(obj, key)) newObj[key] = obj[key]; } } newObj.default = obj; return newObj; } }

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

var Uploader = function () {
    function Uploader(file, canvas) {
        _classCallCheck(this, Uploader);

        this.file = file;
        this.canvas = canvas;
    }

    /*
        Parse the CSV
    */


    _createClass(Uploader, [{
        key: 'parse',
        value: function parse(vehiclesForContract) {
            var _this = this;

            return new Promise(function (resolve, reject) {
                _papaparse2.default.parse(_this.file, {
                    complete: function complete(results) {
                        var shifts = [];
                        //Remove first line, as it contains headers
                        results.data.shift();

                        var _iteratorNormalCompletion = true;
                        var _didIteratorError = false;
                        var _iteratorError = undefined;

                        try {
                            for (var _iterator = results.data[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
                                var line = _step.value;

                                try {
                                    shifts.push(_this.parseLine(line, vehiclesForContract));
                                } catch (e) {
                                    reject(e);
                                }
                            }
                        } catch (err) {
                            _didIteratorError = true;
                            _iteratorError = err;
                        } finally {
                            try {
                                if (!_iteratorNormalCompletion && _iterator.return) {
                                    _iterator.return();
                                }
                            } finally {
                                if (_didIteratorError) {
                                    throw _iteratorError;
                                }
                            }
                        }

                        var _iteratorNormalCompletion2 = true;
                        var _didIteratorError2 = false;
                        var _iteratorError2 = undefined;

                        try {
                            for (var _iterator2 = shifts[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
                                var shift = _step2.value;

                                _this.canvas.shifts.push(shift);
                            }
                        } catch (err) {
                            _didIteratorError2 = true;
                            _iteratorError2 = err;
                        } finally {
                            try {
                                if (!_iteratorNormalCompletion2 && _iterator2.return) {
                                    _iterator2.return();
                                }
                            } finally {
                                if (_didIteratorError2) {
                                    throw _iteratorError2;
                                }
                            }
                        }

                        _this.canvas.render();

                        resolve();
                    },
                    error: function error(err) {
                        reject(err);
                    },
                    header: false,
                    skipEmptyLines: true
                });
            });
        }
    }, {
        key: 'parseLine',
        value: function parseLine(line, vehiclesForContract) {
            if (line.length < 12) throw 'Line only has ' + line.length + ' columns.';

            this.canvas.localShifts++;
            var shift = {
                shiftId: this.canvas.localShifts,
                startTime: line[4],
                endTime: line[5],
                state: 'inactive',
                startLocation: {
                    locationType: 'gpscoord',
                    coordinate: { x: this.parseCsvFloat(line[7]), y: this.parseCsvFloat(line[6]) },
                    geoType: 'wgs84',
                    POIName: line[8]
                },
                endLocation: {
                    locationType: 'gpscoord',
                    coordinate: { x: this.parseCsvFloat(line[10]), y: this.parseCsvFloat(line[9]) },
                    geoType: 'wgs84',
                    POIName: line[11]
                }
            };

            if (line[0] != '') {
                shift.driver = {
                    id: parseInt(line[0]),
                    hashId: '',
                    firstName: line[1],
                    lastName: '',
                    telephone: '',
                    email: '',
                    driverCardId: 0,
                    companyId: 0
                };
            }

            shift.vehicle = {};
            if (line[2] != '') {
                shift.vehicle.licensePlate = line[2];

                var vehicleForLicensPlate = vehiclesForContract.filter(function (item) {
                    if (item.licensePlate == shift.vehicle.licensePlate) return lookup_item;
                })[0];
                if (vehicleForLicensPlate && vehicleForLicensPlate !== 'undefined') {
                    shift.vehicle = vehicleForLicensPlate;
                }
            } else if (line[3] != '') {
                shift.vehicle.vehicleType = line[3];
                var vehicleForType = vehiclesForContract.filter(function (item) {
                    if (item.vehicleType == shift.vehicle.vehicleType) return lookup_item;
                })[0];

                if (vehicleForType && vehicleForType !== 'undefined') {
                    shift.vehicle = vehicleForType;
                }
            }

            try {
                return new _Shift2.default(new AbelKitWebAdmin.Objects.AKShift(shift), 'local');
            } catch (e) {
                throw e.message.message;
            }
        }
    }, {
        key: 'parseCsvFloat',
        value: function parseCsvFloat(string) {
            string.replace(/,/g, '.');
            string.replace(/\.(?=.*\.)/g, '');
            return string;
        }
    }]);

    return Uploader;
}();

exports.default = Uploader;

},{"./Shift":17,"abelkit-js":"abelkit-js","papaparse":"papaparse"}],21:[function(require,module,exports){
'use strict';

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

var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }();

var _BaseController2 = require('./BaseController');

var _BaseController3 = _interopRequireDefault(_BaseController2);

var _Autocomplete = require('./Autocomplete/Autocomplete');

var _Autocomplete2 = _interopRequireDefault(_Autocomplete);

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

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

function _possibleConstructorReturn(self, call) { if (!self) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return call && (typeof call === "object" || typeof call === "function") ? call : self; }

function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function, not " + typeof superClass); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, enumerable: false, writable: true, configurable: true } }); if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass; } /*global $*/

var TripController = function (_BaseController) {
    _inherits(TripController, _BaseController);

    function TripController(abelKit) {
        _classCallCheck(this, TripController);

        var _this = _possibleConstructorReturn(this, (TripController.__proto__ || Object.getPrototypeOf(TripController)).call(this, abelKit));

        var completeFromLocationService = abelKit._admin.get('contracts').getSettingForSelectedContract('requireMeetingpoint') == false;
        var placeSelectionCallback = function placeSelectionCallback(elementId, suggestion) {
            var which = 'to';
            if (elementId.includes("from")) {
                which = 'from';
            }

            // set value
            $('#trip_' + which).val(suggestion.location.POIName);

            $('#trip_' + which + '_street_number').val(suggestion.location.houseNumber);
            $('#trip_' + which + '_route').val(suggestion.location.street);
            $('#trip_' + which + '_locality').val(suggestion.location.place);
            $('#trip_' + which + '_country').val(suggestion.location.countryCode);
            $('#trip_' + which + '_postal_code').val(suggestion.location.zip);
            $('#trip_' + which + '_poi_name').val(suggestion.location.POIName);
            $('#trip_' + which + '_lat').val(suggestion.location.coordinate.y);
            $('#trip_' + which + '_lng').val(suggestion.location.coordinate.x);
        };

        _this.autocomplete = new _Autocomplete2.default(abelKit, ['#trip_from', '#trip_to'], placeSelectionCallback, true, completeFromLocationService);
        return _this;
    }

    _createClass(TripController, [{
        key: 'new',
        value: function _new() {
            var _this2 = this;

            $('#trip_from, #trip_to').keydown(function (evt) {
                var keycode = event.keyCode;
                var valid = keycode > 47 && keycode < 58 || // number keys
                keycode > 64 && keycode < 91 || // letter keys
                keycode > 95 && keycode < 112 || // numpad keys
                keycode > 185 && keycode < 193 || // ;=,-./` (in order)
                keycode > 218 && keycode < 223; // [\]' (in order)

                if (valid) {
                    var which = 'to';
                    if (evt.target.id == 'trip_from') {
                        which = 'from';
                    }
                    _this2.clearLocation(which);
                }
            });
        }
    }, {
        key: 'clearLocation',
        value: function clearLocation(which) {
            $('#trip_' + which + '_street_number').val('');
            $('#trip_' + which + '_route').val('');
            $('#trip_' + which + '_locality').val('');
            $('#trip_' + which + '_country').val('');
            $('#trip_' + which + '_postal_code').val('');
            $('#trip_' + which + '_poi_name').val('');
            $('#trip_' + which + '_lat').val('');
            $('#trip_' + which + '_lng').val('');
        }
    }]);

    return TripController;
}(_BaseController3.default);

exports.default = TripController;

},{"./Autocomplete/Autocomplete":2,"./BaseController":3}],22:[function(require,module,exports){
'use strict';

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

var _createClass = function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; }(); /*global updateTemplate, $*/

var _abelkitJs = require('abelkit-js');

var _abelkitJs2 = _interopRequireDefault(_abelkitJs);

var _SchedulerController = require('./Components/SchedulerController');

var _SchedulerController2 = _interopRequireDefault(_SchedulerController);

var _TripController = require('./Components/TripController');

var _TripController2 = _interopRequireDefault(_TripController);

var _PromocodeController = require('./Components/PromocodeController');

var _PromocodeController2 = _interopRequireDefault(_PromocodeController);

var _MeetingPointController = require('./Components/MeetingPointController');

var _MeetingPointController2 = _interopRequireDefault(_MeetingPointController);

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

function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

/*import $ from 'jquery';
window.jQuery = window.$ = $;
require('bootstrap');*/

var AdminPanel = function () {
    function AdminPanel() {
        var _this = this;

        _classCallCheck(this, AdminPanel);

        var config = void 0;
        try {
            config = require('../../config');
        } catch (e) {
            var _config = {};
        }
        this.abelKit = new _abelkitJs2.default(config);

        this.abelKit.adminLogin(this.onLogin, function (type, error) {
            $.bootstrapGrowl(error, { delay: 2000, type: 'danger' });
        });

        this.view = null;

        $(window).bind('storage', function () {
            var contracts = _this.abelKit._admin.get('contracts');
            if (contracts != null) {
                var localStorageContractId = parseInt(localStorage.getItem(_this.abelKit._admin.get('contracts').activeStorageKey));
                if (localStorageContractId != _this.abelKit._admin.get('contracts').getActive().id) {
                    _this.setContract(localStorageContractId);
                }
            }
        });

        if (config && config.appVersion) {
            $('#version_info').html('Version: ' + config.appVersion);
        }
    }

    _createClass(AdminPanel, [{
        key: 'onLogin',
        value: function onLogin() {
            //Set contract
            updateTemplate();
            $(window).hashchange();
        }
    }, {
        key: 'scheduler',
        value: function scheduler() {
            this.view = new _SchedulerController2.default(this.abelKit);
        }
    }, {
        key: 'trip',
        value: function trip() {
            this.view = new _TripController2.default(this.abelKit);
        }
    }, {
        key: 'promocode',
        value: function promocode() {
            this.view = new _PromocodeController2.default(this.abelKit);
        }
    }, {
        key: 'meetingPoints',
        value: function meetingPoints() {
            this.view = new _MeetingPointController2.default(this.abelKit);
        }
    }, {
        key: 'setContract',
        value: function setContract(contractId) {
            this.abelKit.setContract(contractId);
            updateTemplate();
            $(window).hashchange();
        }
    }, {
        key: 'logout',
        value: function logout() {
            this.abelKit.adminLogout();
            $('#content_container').html('Close your browser now.');
            $('#user_name').html('');
        }
    }]);

    return AdminPanel;
}();

exports.default = AdminPanel;

},{"../../config":1,"./Components/MeetingPointController":5,"./Components/PromocodeController":13,"./Components/SchedulerController":14,"./Components/TripController":21,"abelkit-js":"abelkit-js"}]},{},[22])(22)
});

//# sourceMappingURL=maps/app.js.map