workarea-admin 3.4.12

data/app/assets/javascripts/workarea/admin/google_analytics.js

@@ -0,0 +1,6 @@
+document.addEventListener('turbolinks:load', function(event) {
+    if (typeof window.ga === 'function') {
+        window.ga('set', 'location', event.data.url);
+        window.ga('send', 'pageview');
+    }
+});

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

@@ -0,0 +1,71 @@
+/**
+ * @namespace WORKAREA.addContentBlockButtons
+ */
+WORKAREA.registerModule('addContentBlockButtons', (function () {
+    'use strict';
+
+    var loadingIndicator = JST['workarea/admin/templates/loading'],
+
+        injectBlocks = function (response) {
+            var $response = $(response);
+
+            $('#takeover .takeover__content').empty().append($response);
+
+            // in order for tooltipster to find the proper IDs within the
+            // content block takeover, modules must be initialized _after_
+            // the DOM is appended.
+            WORKAREA.initModules($response);
+        },
+
+        fetchBlocks = function (button) {
+            $.get(button.href).done(injectBlocks);
+        },
+
+        openLoadingTakeover = function (button) {
+            WORKAREA.takeover.open(loadingIndicator({
+                cssModifiers: 'loading--large loading--fill-parent'
+            }));
+
+            return button;
+        },
+
+        preventClick = function (event) {
+            event.preventDefault();
+            return event.currentTarget;
+        },
+
+        loadBlocks = _.flow(preventClick, openLoadingTakeover, fetchBlocks),
+
+        /**
+         * [reorder description]
+         * @return {[type]} [description]
+         */
+        reorder = function () {
+            var $blocks = $('#content_editor .content-block');
+
+            $blocks.each(function (blockIndex, block) {
+                var $buttons = $('[data-add-content-block-button]', block);
+
+                $buttons.each(function (buttonIndex, button) {
+                    var newIndex = $(block).data('blockOrder') + buttonIndex;
+
+                    button.href = WORKAREA.url.updateParams(button.href, {'position': newIndex});
+                });
+            });
+        },
+
+        /**
+         * @method
+         * @name init
+         * @memberof WORKAREA.addContentBlockButtons
+         */
+        init = function ($scope) {
+            $('[data-add-content-block-button]', $scope)
+            .on('click', loadBlocks);
+        };
+
+    return {
+        init: init,
+        reorder: reorder
+    };
+}()));

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

@@ -0,0 +1,45 @@
+/**
+ * @namespace WORKAREA.addToCalendarButtons
+ */
+WORKAREA.registerModule('addToCalendarButtons', (function () {
+    'use strict';
+
+    var toggleContent = function ($button, $moreInfo, event) {
+            event.preventDefault();
+            $button.tooltipster('content', $moreInfo);
+        },
+
+        initTooltip = function (button, $content) {
+            var config = _.merge({}, WORKAREA.config.tooltipster, {
+                    content: $content,
+                    interactive: true
+                });
+
+            return $(button).tooltipster(config);
+        },
+
+        setup = function (index, button) {
+            var data = $(button).data('addToCalendarButton'),
+                $initial = $(data.initial),
+                $moreInfo = $(data.moreInfo),
+                $button = initTooltip(button, $initial),
+                toggle = _.partial(toggleContent, $button, $moreInfo);
+
+            $initial
+                .find('[data-add-to-calendar-button-toggle]')
+                .on('click', toggle);
+        },
+
+        /**
+         * @method
+         * @name init
+         * @memberof WORKAREA.addToCalendarButtons
+         */
+        init = function ($scope) {
+            $('[data-add-to-calendar-button]', $scope).each(setup);
+        };
+
+    return {
+        init: init
+    };
+}()));

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

@@ -0,0 +1,51 @@
+/**
+ * @namespace WORKAREA.assetPickerFields
+ */
+WORKAREA.registerModule('assetPickerFields', (function () {
+    'use strict';
+
+    var addAsset = function (assetPickerField, event, asset) {
+            $('input', assetPickerField).val(asset.id).trigger('change');
+            $('[data-asset-name]', assetPickerField).text(asset.name);
+            $('[data-asset-url]', assetPickerField).val(asset.url).trigger('change');
+            $(window).off('assetPickers:insert');
+        },
+
+        clearAsset = function (event) {
+            var assetPickerField = event.delegateTarget;
+
+            $('input', assetPickerField).val('').trigger('change');
+            $('[data-asset-name]', assetPickerField).text(
+                I18n.t('workarea.admin.content_blocks.asset.name_missing')
+            );
+        },
+
+        openAssetPickerTakeover = function (event) {
+            event.preventDefault();
+
+            $.get(event.currentTarget.href).done(function (response) {
+                WORKAREA.takeover.open(response, {
+                    reloadUrl: event.currentTarget.href
+                });
+            });
+
+            $(window).on(
+                'assetPickers:insert', _.partial(addAsset, event.delegateTarget)
+            );
+        },
+
+        /**
+         * @method
+         * @name init
+         * @memberof WORKAREA.assetPickerFields
+         */
+        init = function ($scope) {
+            $('[data-asset-picker-field]', $scope)
+            .on('click', '[data-asset-picker-field-open]', openAssetPickerTakeover)
+            .on('click', '[data-asset-picker-field-clear]', clearAsset);
+        };
+
+    return {
+        init: init
+    };
+}()));

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

@@ -0,0 +1,65 @@
+/**
+ * @namespace WORKAREA.assetPickers
+ */
+WORKAREA.registerModule('assetPickers', (function () {
+    'use strict';
+
+    var announceEvent = function (summary) {
+            var data = $(summary).data('asset');
+
+            $(window).trigger('assetPickers:insert', data);
+
+            WORKAREA.takeover.close();
+        },
+
+        requestPage = function (requestData) {
+            $.get(requestData.endpoint, requestData.data || {})
+            .done(WORKAREA.takeover.update);
+        },
+
+        getRequestData = function (element) {
+            var requestData = {};
+
+            if (_.isUndefined(element.action)) {
+                requestData.endpoint = element.href;
+            } else {
+                requestData.endpoint = element.action;
+                requestData.data = $(element).serialize();
+            }
+
+            return requestData;
+        },
+
+        stopEvent = function (event) {
+            event.preventDefault();
+            return event.currentTarget;
+        },
+
+        handleSummaryClick = _.flow(stopEvent, announceEvent),
+
+        /**
+         * Handles a click or submit event asyncronously, replacing the current
+         * Takeover with the content from the async call.
+         * @type {function}
+         * @param {event} event the click or submit event
+         */
+        handleInteraction = _.flow(stopEvent, getRequestData, requestPage),
+
+        /**
+         * @method
+         * @name init
+         * @memberof WORKAREA.assetPickers
+         */
+        init = function ($scope) {
+            $('[data-asset-picker]', $scope)
+                .addBack('[data-asset-picker]')
+                .on('submit', 'form', handleInteraction)
+                .on('click', 'a:not([data-asset])', handleInteraction)
+                .on('click', '[data-asset]', handleSummaryClick);
+        };
+
+    return {
+        init: init,
+        handleInteraction: handleInteraction
+    };
+}()));

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

@@ -0,0 +1,55 @@
+/**
+ * @namespace WORKAREA.autocompleteFields
+ */
+WORKAREA.registerModule('autocompleteFields', (function () {
+    'use strict';
+
+    var addPlaceholder = function ($field) {
+            var placeholder = $field.prop('placeholder') ||
+                I18n.t('workarea.admin.js.autocomplete_fields.placeholder');
+
+            $field.prop('placeholder', placeholder);
+        },
+
+        getSource = function (url) {
+            return function (request, response) {
+                $.getJSON(url, { q: request.term }, function (data) {
+                    response(data.results);
+                });
+            };
+        },
+
+        initAutocomplete = function ($field) {
+            var url = $field.data('autocompleteField');
+
+            return $field.autocomplete({
+                minLength: 2,
+                source: getSource(url),
+                position: {
+                    my: 'center top',
+                    at: 'center bottom',
+                    collision: 'none'
+                }
+            });
+        },
+
+        defineInjectionPoint = function (index, field) {
+            $(field).parent().addClass('ui-front');
+            return $(field);
+        },
+
+        setup = _.flow(defineInjectionPoint, initAutocomplete, addPlaceholder),
+
+        /**
+         * @method
+         * @name init
+         * @memberof WORKAREA.autocompleteFields
+         */
+        init = function ($scope) {
+            $('[data-autocomplete-field]', $scope).each(setup);
+        };
+
+    return {
+        init: init
+    };
+}()));

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

@@ -0,0 +1,40 @@
+/**
+ * @namespace WORKAREA.bookmarks
+ */
+WORKAREA.registerModule('bookmarks', (function () {
+    'use strict';
+
+    var findBookmarkName = function () {
+            return $('head title').text();
+        },
+
+        findBookmarkPath = function () {
+            return window.location.pathname + window.location.search;
+        },
+
+        createBookmark = function (event) {
+            var form = JST['workarea/admin/templates/bookmark_form']({
+                url: WORKAREA.routes.admin.bookmarksPath(),
+                csrfParam: $('meta[name=csrf-param]').attr('content'),
+                csrfToken: $('meta[name=csrf-token]').attr('content'),
+                name: findBookmarkName(),
+                path: findBookmarkPath()
+            });
+
+            event.preventDefault();
+            $(form).hide().appendTo('body').submit();
+        },
+
+        /**
+         * @method
+         * @name init
+         * @memberof WORKAREA.bookmarks
+         */
+        init = function ($scope) {
+            $('[data-bookmark]', $scope).on('click', createBookmark);
+        };
+
+    return {
+        init: init
+    };
+}()));

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

@@ -0,0 +1,43 @@
+/**
+ * @namespace WORKAREA.bulkActionDeletion
+ */
+WORKAREA.registerModule('bulkActionDeletion', (function () {
+    'use strict';
+
+    var generateMessage = function(count) {
+            return I18n.t('workarea.admin.bulk_action_deletions.confirmation', { count: count });
+        },
+
+        getSessionCount = function($scope) {
+            var session = WORKAREA.bulkActionItems.getSession(),
+                $countUI = $('[data-bulk-action-item-count]', $scope);
+
+            if (_.isNull(session)) { return $countUI.data('bulkActionItemCount'); }
+            return session.count === 0 ? session.initialCount : session.count;
+        },
+
+        confirmBulkDelete = function($scope, event) {
+            var count = getSessionCount($scope),
+                threshold = WORKAREA.config.bulkActionDeletion.threshold,
+                message = generateMessage(count);
+
+            if (count < threshold && ! window.confirm(message)) {
+                event.preventDefault();
+                event.stopImmediatePropagation();
+            }
+        },
+
+        /**
+         * @method
+         * @name init
+         * @memberof WORKAREA.bulkActionDeletion
+         */
+        init = function ($scope) {
+            $('[data-bulk-action-deletion]', $scope)
+            .on('submit', _.partial(confirmBulkDelete, $scope));
+        };
+
+    return {
+        init: init
+    };
+}()));

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

@@ -0,0 +1,319 @@
+/**
+ * @namespace WORKAREA.bulkActionItems
+ */
+WORKAREA.registerModule('bulkActionItems', (function () {
+    'use strict';
+
+    var hiddenInput = JST['workarea/core/templates/hidden_input'],
+        countUI = JST['workarea/admin/templates/bulk_action_items_count'],
+
+        storage = window.sessionStorage,
+
+
+        //
+        // Utility
+        buildInputGroup = function (collection, group) {
+            return _.map(collection, function (value) {
+                var result = hiddenInput({ name: group + '[]', value: value });
+                return $(result).data('addedByBulkActionItem', true);
+            });
+        },
+
+
+        //
+        // Session
+        removeSession = function () {
+            storage.removeItem('bulkActionItems');
+        },
+
+        setSession = function (state) {
+            storage.setItem('bulkActionItems', JSON.stringify(state));
+        },
+
+        /**
+         * @method
+         * @name getSession
+         * @memberof WORKAREA.bulkActionItems
+         */
+        getSession = function () {
+            return JSON.parse(storage.getItem('bulkActionItems'));
+        },
+
+        initSession = _.once(setSession),
+
+        setup = function ($scope) {
+            var state = {}, initialCount;
+
+            initialCount = $('[data-browsing-controls-count]', $scope).data(
+                'browsingControlsCount'
+            );
+
+            state.ids = [];
+            state.count = 0;
+            state.excludeIds = [];
+            state.includeAll = false;
+            state.pathname = window.location.pathname;
+            state.initialCount = initialCount;
+            initSession(state);
+
+            return state;
+        },
+
+        sessionApplicable = function () {
+            var session = getSession();
+            return session && session.pathname === window.location.pathname;
+        },
+
+
+        //
+        // State Management
+        toggleSelectAll = function (scope, session) {
+            var $selectAll = $('[data-bulk-action-select-all]', scope),
+                $selectAllCheckbox = $selectAll.closest('.checkbox'),
+                allSelected = session.count === session.initialCount;
+
+            if (allSelected) {
+                $selectAll.prop('checked', true);
+            } else {
+                $selectAll.prop('checked', false);
+            }
+
+            if (session.count === 0) {
+                $selectAllCheckbox.removeClass('checkbox--indeterminate');
+            } else {
+                $selectAllCheckbox.addClass('checkbox--indeterminate');
+            }
+        },
+
+        toggleCountUI = function ($ui, count) {
+            var $parent = $ui.parent();
+
+            if (count > 0) {
+                $parent.removeClass('hidden');
+            } else if (count <= 0) {
+                $parent.addClass('hidden');
+            }
+        },
+
+        setCount = function (scope, count) {
+            var $ui = $('[data-bulk-action-item-count]', scope);
+
+            if (_.isEmpty($ui)) {
+                var $placeholder = $('[data-bulk-action-count-placeholder]', scope),
+                    $countUI = $(countUI({ count: count }));
+
+                if (count <= 0) {
+                    $countUI.addClass('hidden');
+                }
+
+                $placeholder.replaceWith($countUI);
+            } else {
+                $ui.text(count);
+            }
+
+            toggleCountUI($ui, count);
+        },
+
+        reset = function ($scope) {
+            var $selectAll, $itemInputs, $count, $forms;
+
+            $scope = ($scope instanceof jQuery) ? $scope : $(document);
+            $selectAll = $('[data-bulk-action-select-all]', $scope),
+            $itemInputs = $('[data-bulk-action-item]', $scope);
+            $count = $('[data-bulk-action-item-count]', $scope);
+            $forms = $('[data-bulk-action-form]', $scope);
+
+            $selectAll.prop('checked', false);
+            $itemInputs.prop('checked', false);
+
+            $count.text($count.data('bulkActionItemCount'));
+
+            $('input', $forms).filter(function(index, input) {
+                return $(input).data('addedByBulkActionItem');
+            }).remove();
+        },
+
+        destroy = _.flow(reset, removeSession),
+
+        recall = function ($scope) {
+            var session = getSession(),
+                $selectAll = $('[data-bulk-action-select-all]', $scope),
+                $itemInputs = $('[data-bulk-action-item]', $scope),
+
+                selectedItems = function (index, item) {
+                    return _.includes(session.ids, item.value);
+                },
+
+                itemsNotExcluded = function (index, item) {
+                    return ! _.includes(session.excludeIds, item.value);
+                };
+
+            if (session.includeAll) {
+                $selectAll.prop('checked', true);
+
+                if (_.isEmpty(session.excludeIds)) {
+                    $itemInputs.prop('checked', true);
+                } else {
+                    $itemInputs.filter(itemsNotExcluded).prop('checked', true);
+                }
+            } else {
+                if ( ! _.isEmpty(session.ids)) {
+                    $itemInputs.filter(selectedItems).prop('checked', true);
+                }
+            }
+
+            setCount($scope, session.count);
+        },
+
+
+        //
+        // Bootstrap
+        removeAll = function (event, session) {
+            var $itemInputs =
+                    $(event.target)
+                        .closest('table')
+                            .find('[data-bulk-action-item]');
+
+            $itemInputs.prop('checked', false);
+
+            session.ids = [];
+            session.excludeIds = [];
+            session.includeAll = false;
+            session.count = 0;
+
+            return session;
+        },
+
+        addAll = function (event, session) {
+            var $itemInputs =
+                    $(event.target)
+                        .closest('table')
+                            .find('[data-bulk-action-item]');
+
+            $itemInputs.prop('checked', true);
+
+            session.ids = [];
+            session.excludeIds = [];
+            session.includeAll = true;
+            session.count = session.initialCount;
+
+            return session;
+        },
+
+        remove = function (event, session) {
+            if (session.includeAll) {
+                session.excludeIds.push(event.target.value);
+            } else {
+                _.remove(session.ids, function (id) {
+                    return id === event.target.value;
+                });
+            }
+
+            session.count -= 1;
+
+            return session;
+        },
+
+        add = function (event, session) {
+            if (session.includeAll) {
+                _.remove(session.excludeIds, function (id) {
+                    return id === event.target.value;
+                });
+            } else {
+                session.ids.push(event.target.value);
+            }
+
+            session.count += 1;
+
+            return session;
+        },
+
+
+        //
+        // Event Handlers
+        handleButtons = function (event) {
+            var session = getSession(), idInputs, excludeIdsInputs;
+
+            if (_.isNull(session)) { return; }
+
+            idInputs = buildInputGroup(session.ids, 'ids'),
+            excludeIdsInputs = buildInputGroup(session.excludeIds, 'exclude_ids');
+
+            _.each(idInputs.concat(excludeIdsInputs), function($input) {
+                $input.appendTo(event.target);
+            });
+
+            removeSession();
+        },
+
+        handleSelectAll = function (event) {
+            var session = getSession() || setup(),
+                $selectAll = $(event.target).parent('.checkbox'),
+                wasChecked = event.target.checked,
+                someSelected = $selectAll.is('.checkbox--indeterminate'),
+                allSelected = session.count === session.initialCount,
+                shouldSelectAll;
+
+            event.preventDefault();
+
+            if (wasChecked) {
+                if (someSelected || allSelected) {
+                    shouldSelectAll = false;
+                } else {
+                    shouldSelectAll = true;
+                }
+            } else {
+                shouldSelectAll = false;
+            }
+
+            if (shouldSelectAll) {
+                session = addAll(event, session);
+                $(event.target).prop('checked', true);
+            } else {
+                session = removeAll(event, session);
+                $(event.target).prop('checked', false);
+            }
+
+            setSession(session);
+            toggleSelectAll(event.delegateTarget, session);
+            setCount(event.delegateTarget, session.count);
+        },
+
+        handleItems = function (event) {
+            var session = getSession() || setup();
+
+            if (event.target.checked) {
+                session = add(event, session);
+            } else {
+                session = remove(event, session);
+            }
+
+            setSession(session);
+            toggleSelectAll(event.delegateTarget, session);
+            setCount(event.delegateTarget, session.count);
+        },
+
+        /**
+         * @method
+         * @name init
+         * @memberof WORKAREA.bulkActionItems
+         */
+        init = function ($scope) {
+            $scope
+            .on('change', '[data-bulk-action-item]', handleItems)
+            .on('change', '[data-bulk-action-select-all]', handleSelectAll)
+            .on('submit', '[data-bulk-action-form]', handleButtons)
+                .find('.browsing-controls')
+                .on('click', 'a', removeSession)
+                .on('submit', 'form', removeSession);
+
+            sessionApplicable() ? recall($scope) : destroy($scope);
+        };
+
+    $(document).on('turbolinks:before-cache', reset);
+
+    return {
+        init: init,
+        getSession: getSession
+    };
+}()));