workarea-admin 3.4.12

data/app/assets/javascripts/workarea/admin/modules/sort_variants.js

@@ -0,0 +1,67 @@
+/**
+ * @namespace WORKAREA.sortVariants
+ */
+WORKAREA.registerModule('sortVariants', (function () {
+    'use strict';
+
+    var findVariantPositions = function (event) {
+            var result = {},
+                $variants = $('[data-sort-variant-id]', event.target);
+
+            $variants.each(function (index, menu) {
+                var id = $(menu).data('sortVariantId');
+
+                if (id) {
+                    result['positions[' + id + ']'] = index;
+                }
+            });
+
+            return result;
+        },
+
+        saveSort = function (event) {
+            var productId = $(event.target)
+                                .closest('[data-sort-variant]')
+                                .data('productId'),
+
+                url = WORKAREA.routes.admin.moveCatalogProductVariantsPath(
+                    { catalog_product_id: productId }
+                );
+
+            $.post(url, findVariantPositions(event));
+        },
+
+        setCellWidth = function (event, ui) {
+            $('td', ui.item).each(function (index, cell) {
+                $(cell).width($(cell).width());
+            });
+
+            return ui;
+        },
+
+        resetCellWidth = function (event, ui) {
+            $('td', ui.item).each(function (index, cell) {
+                $(cell).width('auto');
+            });
+
+            return ui;
+        },
+
+        /**
+         * @method
+         * @name init
+         * @memberof WORKAREA.sortVariants
+         */
+        init = function ($scope) {
+            $('[data-sort-variant]', $scope).sortable({
+                axis: 'y',
+                update: saveSort,
+                helper: setCellWidth,
+                stop: resetCellWidth
+            });
+        };
+
+    return {
+        init: init
+    };
+}()));

data/app/assets/javascripts/workarea/admin/modules/tabs.js

@@ -0,0 +1,66 @@
+/**
+ * @namespace WORKAREA.tabs
+ */
+WORKAREA.registerModule('tabs', (function () {
+    'use strict';
+
+    var tabMenuTemplate = JST['workarea/admin/templates/tabs_menu'],
+
+        initTabsUi = function ($ui) {
+            $ui.tabs();
+        },
+
+        injectTabMenu = function ($ui, tabMenuData, tabIndex) {
+            $ui.prepend(tabMenuTemplate({
+                tabs: tabMenuData,
+                tabIndex: tabIndex
+            }));
+        },
+
+        setPanelIds = function ($panels, tabIds, tabIndex) {
+            $panels.each(function (index, panel) {
+                panel.id = tabIds[index] + '-tab-panel-' + tabIndex;
+            });
+        },
+
+        getTabIds = function (tabName, index) {
+            return WORKAREA.string.dasherize(tabName) + '-' + index;
+        },
+
+        getTabNames = function ($panels) {
+            return $('> .tabs__heading', $panels).map(function (index, name) {
+                return _.trim($(name).text());
+            }).toArray();
+        },
+
+        setupTabsUi = function (index, element) {
+            var $ui = $(element),
+                $panels = $('> .tabs__panel', $ui),
+                tabNames = getTabNames($panels),
+                tabIds = _.map(tabNames, getTabIds),
+                tabMenuData = _.zip(tabNames, tabIds);
+
+            setPanelIds($panels, tabIds, index);
+            injectTabMenu($ui, tabMenuData, index);
+            initTabsUi($ui);
+        },
+
+        destroy = function() {
+            $('.tabs__menu').remove();
+        },
+
+        /**
+         * @method
+         * @name init
+         * @memberof WORKAREA.tabs
+         */
+        init = function ($scope) {
+            $('.tabs', $scope).each(setupTabsUi);
+        };
+
+        $(document).on('turbolinks:before-cache', destroy);
+
+    return {
+        init: init
+    };
+}()));

data/app/assets/javascripts/workarea/admin/modules/takeover.js

@@ -0,0 +1,154 @@
+/**
+ * Creates a UI that takes over the current page, using the `.header` component
+ * for it's controls.
+ *
+ * @namespace WORKAREA.takeover
+ */
+WORKAREA.registerModule('takeover', (function () {
+    'use strict';
+
+    var takeover = JST['workarea/admin/templates/takeover'],
+
+        handleEscKey = _.once(function () {
+            $(window).on('keyup.takeover', function (event) {
+                if (event.keyCode !== 27) { return; } // only care about escape
+                close();
+            });
+        }),
+
+        /**
+         * Closes and destroys a takeover.
+         * @param  {Boolean} force bypasses transitionevent (optional)
+         */
+        close = function (force) {
+            var $takeover = $('#takeover');
+
+            $('#header').removeClass('header--takeover');
+            $takeover.addClass('takeover--removing');
+
+            if (!feature.cssTransform || force) {
+                $takeover.remove();
+            } else {
+                $takeover.on(WORKAREA.transitionEvents.detect(), function(event) {
+                    $(event.currentTarget).remove();
+                });
+            }
+        },
+
+        create = function (content, options) {
+            var $takeover = $(takeover({
+                content: content,
+                takeoverClass: options.takeoverClass || ''
+            }));
+
+            $takeover.data('takeoverOptions', options);
+
+            WORKAREA.initModules($takeover);
+
+            $('body').append($takeover);
+
+            return $takeover;
+        },
+
+        addClass = function () {
+            $('#header').addClass('header--takeover');
+        },
+
+        bindCloseButton = function () {
+            var $closeButton = $('#takeover_close_button');
+
+            if ($closeButton.data('takeoverCloseButton')) { return; }
+
+            $closeButton.on('click', close);
+            $closeButton.data('takeoverCloseButton', true);
+
+            handleEscKey();
+        },
+
+        allowOneTakeover = function () {
+            if ( ! _.isEmpty($('#takeover'))) {
+                throw new Error(
+                    I18n.t('workarea.admin.js.takeover.allow_one_takeover')
+                );
+            }
+        },
+
+        /**
+         * Updates the takeover content
+         * @param  {string} content content a string of HTML to show in the takeover
+         * @return {jQuery} an instance of the takeover
+         */
+        update = function (content) {
+            var $content = $(content);
+
+            WORKAREA.initModules($content);
+
+            $('#takeover .takeover__content')
+            .empty()
+            .append($content);
+
+            return $('#takeover');
+        },
+
+        setup = _.flow(allowOneTakeover, bindCloseButton, addClass),
+
+        /**
+         * Opens a takeover UI.
+         * @param {string} content a string of HTML to show in the takeover
+         * @return {jQuery} an instance of the takeover
+         */
+        open = function(content, options) {
+            options = options || {};
+
+            setup();
+            return create(content, options);
+        },
+
+        /**
+         * Returns the current takeover UI instance
+         * @returns {jQuery} the takeover
+         */
+        current = function () {
+            return $('#takeover');
+        },
+
+        /**
+         * Reloads the current takeover UI
+         */
+        reload = function () {
+            var $takeover = current();
+            var options;
+
+            if (_.isEmpty($takeover)) {
+                throw new Error(
+                    'WORKAREA.takeover.reload: could not find an open ' +
+                    'takeover to reload.'
+                );
+            }
+
+            options = $takeover.data('takeoverOptions');
+
+            if (_.isEmpty(options.reloadUrl)) {
+                throw new Error(
+                    'WORKAREA.takeover.reload: could not reload the takeover ' +
+                    'due to a missing `reloadUrl` option that should have ' +
+                    'been passed to the `WORKAREA.takeover.open` method.'
+                );
+            }
+
+            $.get(options.reloadUrl).done(function (response) {
+                close(true);
+                open(response, options);
+            });
+        };
+
+    $(document).on('turbolinks:before-cache', close);
+
+    return {
+        open: open,
+        close: close,
+        update: update,
+        reload: reload,
+        current: current
+    };
+}()));

data/app/assets/javascripts/workarea/admin/modules/taxon_insert.js

@@ -0,0 +1,96 @@
+/**
+ * @namespace WORKAREA.taxonInsert
+ */
+WORKAREA.registerModule('taxonInsert', (function () {
+    'use strict';
+
+    var setPositionInput = function (event, ui) {
+            var $item = $(ui.item);
+
+            $item
+                .closest('[data-taxon-selection]')
+                    .find('input[name=position]')
+                        .val($item.index());
+        },
+
+        initPositionDragAndDrop = function (container) {
+            $('.menu-editor__menu-list', container)
+            .sortable({
+                stop: setPositionInput,
+                cancel: 'li:not(.handle)'
+            });
+        },
+
+        replaceTaxonomy = function (container, response) {
+            var $newContent = $(response);
+            initPositionDragAndDrop($newContent);
+
+            $('[data-taxon-selection]', container).replaceWith($newContent);
+            return container;
+        },
+
+        fetchTaxonomy = function (taxonId, taxonSelection, container) {
+            var url = WORKAREA.routes.admin.insertNavigationTaxonPath({
+                    id: taxonId,
+                    taxon: taxonSelection,
+                    _options: true
+                });
+
+            $.get(url).done(_.partial(replaceTaxonomy, container));
+        },
+
+        updateSelectMenu = function($select, option) {
+            $select.find('option').each(function(index, el) {
+                if ($(el).text() === option) {
+                    $select[0].selectedIndex = index;
+                }
+            });
+            $select.trigger('change');
+        },
+
+        getTaxonSelection = function($el) {
+            return $el.closest('[data-taxon-selection]').data('taxonSelection');
+        },
+
+        handelTaxonSelectChange = function (event) {
+            var taxonId = $(event.target).val(),
+                taxonSelection = getTaxonSelection($(event.currentTarget)),
+                container = event.delegateTarget;
+
+            fetchTaxonomy(taxonId, taxonSelection, container);
+        },
+
+        handleHomeButton = function(event) {
+            var taxonId = $(event.currentTarget).data('rootTaxonId'),
+                taxonSelection = getTaxonSelection($(event.target)),
+                container = event.delegateTarget;
+
+            fetchTaxonomy(taxonId, taxonSelection, container);
+        },
+
+        handleTaxonClick = function(event) {
+            var $taxon = $(event.currentTarget),
+                taxonName = $('.menu-editor__menu-link-text', $taxon).text(),
+                $taxonInsert = $taxon.closest('[data-taxon-insert]'),
+                $select = $('select', $taxonInsert).last();
+
+            updateSelectMenu($select, taxonName);
+        },
+
+        /**
+         * @method
+         * @name init
+         * @memberof WORKAREA.taxonInsert
+         */
+        init = function ($scope) {
+            $('[data-taxon-insert]', $scope)
+            .on('change', 'select', handelTaxonSelectChange)
+            .on('click', '.menu-editor__list-item', handleTaxonClick)
+            .on('click', '.menu-editor__breadcrumbs-home-button', handleHomeButton)
+            .each(_.rearg(initPositionDragAndDrop, [1, 0]));
+        };
+
+    return {
+        init: init
+    };
+}()));

data/app/assets/javascripts/workarea/admin/modules/taxon_select.js

@@ -0,0 +1,50 @@
+/**
+ * @namespace WORKAREA.taxonSelect
+ */
+WORKAREA.registerModule('taxonSelect', (function () {
+    'use strict';
+
+    var updatePreview = function (container) {
+            var $selectedTaxon = $('[data-taxon-selected]', container),
+                $taxonIdField = $('input[type=hidden]:first', container),
+                selectedTaxonId = $selectedTaxon.data('taxonSelected');
+
+            $taxonIdField.val(selectedTaxonId).trigger('change');
+        },
+
+        replaceTaxonomy = function (container, response) {
+            $('[data-taxon-selected]', container).replaceWith(response);
+            return container;
+        },
+
+        updateTaxonomy = _.flow(replaceTaxonomy, updatePreview),
+
+        fetchTaxonomy = function (event) {
+            event.preventDefault();
+
+            $.get(event.currentTarget.href)
+            .done(_.partial(updateTaxonomy, event.delegateTarget));
+        },
+
+        reset = function (event) {
+            event.preventDefault();
+
+            $.get(WORKAREA.routes.admin.selectNavigationTaxonsPath())
+            .done(_.partial(updateTaxonomy, event.delegateTarget));
+        },
+
+        /**
+         * @method
+         * @name init
+         * @memberof WORKAREA.taxonSelect
+         */
+        init = function ($scope) {
+            $('[data-taxon-select]', $scope)
+            .on('click', 'a', fetchTaxonomy)
+            .on('click', 'button[value=reset]', reset);
+        };
+
+    return {
+        init: init
+    };
+}()));

data/app/assets/javascripts/workarea/admin/modules/toggle_buttons.js

@@ -0,0 +1,50 @@
+/**
+ * @namespace WORKAREA.toggleButtons
+ */
+WORKAREA.registerModule('toggleButtons', (function () {
+    'use strict';
+
+    var toggleElements = function ($radio, positive) {
+            var $container = $radio.closest('[data-toggle-button]'),
+                $elements = $('.toggle-button__more', $container),
+                reverseSwitch = positive ? 'negative' : 'positive',
+                selector = '[data-toggle-button-' + reverseSwitch + '-element]';
+
+            $elements.removeClass('toggle-button__more--active');
+
+            $elements
+                .not(selector)
+                .addClass('toggle-button__more--active');
+        },
+
+        determineState = function ($radio) {
+            if ($radio.is('.toggle-button__input--positive')) {
+                toggleElements($radio, true);
+            } else {
+                toggleElements($radio, false);
+            }
+        },
+
+        getCheckedRadio = function (event) {
+            determineState($(event.currentTarget));
+        },
+
+        getInitialState = function (index, button) {
+            determineState($('.toggle-button__input:checked', button));
+        },
+
+        /**
+         * @method
+         * @name init
+         * @memberof WORKAREA.toggleButtons
+         */
+        init = function ($scope) {
+            $('[data-toggle-button]', $scope)
+            .on('change', '.toggle-button__input', getCheckedRadio)
+            .each(getInitialState);
+        };
+
+    return {
+        init: init
+    };
+}()));