katello 3.11.2 → 3.12.0.rc1

data/engines/bastion/app/assets/javascripts/bastion/components/components.module.js

@@ -0,0 +1,17 @@
+(function () {
+    'use strict';
+
+    /**
+     * @ngdoc module
+     * @name  Bastion.components
+     *
+     * @description
+     *   Cross application re-usable components
+     */
+    angular.module('Bastion.components', [
+        'ngResource',
+        'Bastion.utils',
+        'ui.bootstrap.alert',
+        'ui.bootstrap.tpls'
+    ]);
+})();

data/engines/bastion/app/assets/javascripts/bastion/components/current-tasks.directive.js

@@ -0,0 +1,55 @@
+/**
+ * @ngdoc directive
+ * @name Bastion.components.directive:currentTasks
+ *
+ * @requires $document
+ * @requires authorizationService
+ * @requires Task
+ *
+ * @description
+ *  Provides a widget showing current number of runnings tasks, popping
+ *  up the table of recent tasks when clicked on.
+ *
+ * @example
+    <span current-tasks></span>
+ */
+angular.module('Bastion.components').directive('currentTasks',
+    ['$document', 'authorizationService', 'Task',
+    function ($document, authorizationService, Task) {
+
+        return {
+            restrict: 'A',
+            scope: true,
+            templateUrl: 'components/views/current-tasks.html',
+
+            controller: ['$scope', function ($scope) {
+                // Hide the current tasks list if the user clicks outside of it
+                var currentTasksMenu = angular.element('#currentTasks');
+                $scope.visible = false;
+                $scope.currentUser = authorizationService.getCurrentUser();
+                $scope.count = 0;
+
+                $scope.toggleVisibility = function () {
+                    $scope.visible = !$scope.visible;
+                };
+
+                $scope.updateTasks = function (tasks) {
+                    $scope.count = tasks.length;
+                };
+
+                $document.bind('click', function (event) {
+                    var target = angular.element(event.target);
+                    if (!currentTasksMenu.find(target).length) {
+                        $scope.visible = false;
+                        if (!$scope.$$phase) {
+                            $scope.$apply();
+                        }
+                    }
+                });
+            }],
+            link: function (scope) {
+                var searchParams = {'active_only': true, 'type': 'user', 'user_id': authorizationService.getCurrentUser().id};
+                Task.registerSearch(searchParams, scope.updateTasks);
+            }
+        };
+    }]);

data/engines/bastion/app/assets/javascripts/bastion/components/formatters/array-to-string.filter.js

@@ -0,0 +1,16 @@
+/**
+ * @ngdoc filter
+ * @name  Bastion.components.formatters.filter:arrayToString
+ *
+ * @description
+ *
+ *
+ * @example
+ *
+ */
+angular.module('Bastion.components.formatters').filter('arrayToString', [function () {
+    return function (toFormat, separator) {
+        separator = separator || ', ';
+        return toFormat.join(separator);
+    };
+}]);

data/engines/bastion/app/assets/javascripts/bastion/components/formatters/boolean-to-yes-no.filter.js

@@ -0,0 +1,21 @@
+/**
+ * @ngdoc filter
+ * @name  Bastion.components.formatters.filter:booleanToYesNo
+ *
+ * @requires translate
+ *
+ * @description
+ *   Provides a filter to convert a boolean to Yes/No
+ */
+angular.module('Bastion.components.formatters').filter('booleanToYesNo', ['translate', function (translate) {
+    return function (boolValue, yesValue, noValue) {
+        yesValue = yesValue || translate("Yes");
+        noValue = noValue || translate("No");
+
+        if (boolValue !== '' && boolValue !== null && angular.isDefined(boolValue)) {
+            return (boolValue === true) ? yesValue : noValue;
+        }
+
+        return "";
+    };
+}]);

data/engines/bastion/app/assets/javascripts/bastion/components/formatters/capitalize.filter.js

@@ -0,0 +1,19 @@
+/**
+ * @ngdoc filter
+ * @name  Bastion.components.formatters.filter:capitalize
+ *
+ * @description
+ *   A filter to capitalize the initial letter of a string.
+ *
+ * @example
+ *   {{ 'blah' | capitalize }} will produce the string "Blah".
+ */
+angular.module('Bastion.components.formatters').filter('capitalize', function () {
+    return function (input) {
+        var capitalized = input;
+        if (angular.isString(input)) {
+            capitalized = input.substring(0, 1).toUpperCase() + input.substring(1);
+        }
+        return capitalized;
+    };
+});

data/engines/bastion/app/assets/javascripts/bastion/components/formatters/components-formatters.module.js

@@ -0,0 +1,8 @@
+/**
+ * @ngdoc module
+ * @name  Bastion.components.formatters.format
+ *
+ * @description
+ *   Module for formatting related functionality, primarily filters.
+ */
+angular.module('Bastion.components.formatters', ['ngSanitize']);

data/engines/bastion/app/assets/javascripts/bastion/components/formatters/key-value-to-string.filter.js

@@ -0,0 +1,27 @@
+/**
+ * @ngdoc filter
+ * @name  Bastion.components.formatters.filter:keyValueToString
+ *
+ * @description
+ *
+ *
+ * @example
+ *
+ */
+angular.module('Bastion.components.formatters').filter('keyValueToString', [function () {
+    return function (toFormat, options) {
+        var keyName, valueName, separator;
+        options = options || {};
+        keyName = options.keyName || 'keyname';
+        valueName = options.valueName || 'value';
+        separator = options.separator || ': ';
+
+        if (!(toFormat instanceof Array)) {
+            toFormat = [toFormat];
+        }
+
+        return _.map(toFormat, function (entry) {
+            return [entry[keyName], entry[valueName]].join(separator);
+        }).join(', ');
+    };
+}]);

data/engines/bastion/app/assets/javascripts/bastion/components/formatters/unlimitedFilter.filter.js

@@ -0,0 +1,22 @@
+/**
+ * @ngdoc filter
+ * @name  Bastion.components.formatters.filter:unlimitedFilter
+ *
+ * @description
+ *   Used to format a display value as either a number or the translate text "Unlimited"
+ *   based on a secondary boolean value.
+ *
+ * @example
+ *  {{ hostCollection.max_content_hosts | unlimitedFilter:hostCollection.unlimited_content_hosts }}
+ */
+angular.module('Bastion.components.formatters').filter('unlimitedFilter', ['translate', function (translate) {
+    return function (displayValue, unlimited) {
+        if (unlimited || displayValue === -1) {
+            displayValue = translate("Unlimited");
+        } else if (displayValue) {
+            displayValue = displayValue.toString();
+        }
+
+        return displayValue;
+    };
+}]);

data/engines/bastion/app/assets/javascripts/bastion/components/notification.service.js

@@ -0,0 +1,37 @@
+/**
+ * @ngdoc service
+ * @name  Bastion.components.service:Notification
+ *
+ * @description
+ *  Service to display a foreman toast notification
+ */
+angular.module('Bastion.components').service("Notification", ['$interpolate', 'foreman', function ($interpolate, foreman) {
+    function interpolateIfNeeded(message, context) {
+        var result = message;
+
+        if (context) {
+            result = $interpolate(message)(context);
+        }
+
+        return result;
+    }
+
+    this.setSuccessMessage = function (message, options) {
+        var baseOptions, fullOptions;
+        /* eslint-disable no-unused-expressions */
+        (angular.isUndefined(options)) && (options = {});
+        /* eslint-enable no-unused-expressions */
+        baseOptions = { message: interpolateIfNeeded(message, options.context), type: 'success' };
+        delete options.context;
+        fullOptions = _.extend(baseOptions, options);
+        foreman.toastNotifications.notify(fullOptions);
+    };
+
+    this.setWarningMessage = function (message, context) {
+        foreman.toastNotifications.notify({message: interpolateIfNeeded(message, context), type: 'warning'});
+    };
+
+    this.setErrorMessage = function (message, context) {
+        foreman.toastNotifications.notify({message: interpolateIfNeeded(message, context), type: 'danger'});
+    };
+}]);

data/engines/bastion/app/assets/javascripts/bastion/components/nutupane.factory.js

@@ -0,0 +1,494 @@
+/**
+ * @ngdoc service
+ * @name  Bastion.components.service:Nutupane
+ *
+ * @requires $location
+ * @requires $q
+ * @requires entriesPerPage
+ * @requires TableCache
+ * @requires Notification
+ *
+ * @description
+ *   Defines the Nutupane factory for adding common functionality to the Nutupane master-detail
+ *   pattern.  Note that the API Nutupane uses must provide a response of the following structure:
+ *
+ *   {
+ *      page: 1,
+ *      subtotal: 50,
+ *      total: 100,
+ *      results: [...]
+ *   }
+ *
+ * @example
+ *   <pre>
+       angular.module('example').controller('ExampleController',
+           ['Nutupane', function (Nutupane)) {
+               var nutupane                = new Nutupane(ExampleResource);
+               $scope.table                = nutupane.table;
+           }]
+       );
+    </pre>
+ */
+angular.module('Bastion.components').factory('Nutupane',
+    ['$location', '$q', '$stateParams', 'entriesPerPage', 'TableCache', 'Notification', function ($location, $q, $stateParams, entriesPerPage, TableCache, Notification) {
+        var Nutupane = function (resource, params, action, nutupaneParams) {
+            var self = this;
+
+            function getTableName() {
+                return $location.path().split('/').join('-').slice(1);
+            }
+
+            function setQueryStrings() {
+                // Don't manipulate the query string for params of a modal view
+                if (document.body.className.indexOf("modal-open") >= 0) {
+                    return;
+                }
+
+                if (self.table.params.paged) {
+                    $location.search("page", self.table.params.page).replace();
+                    $location.search("per_page", self.table.params['per_page']).replace();
+                }
+
+                if (self.table.params.search) {
+                    $location.search(self.searchKey, self.table.params.search).replace();
+                }
+
+                if (self.table.params.sort_by) {
+                    $location.search("sortBy", self.table.params['sort_by']).replace();
+                }
+
+                if (self.table.params['sort_order']) {
+                    $location.search("sortOrder", self.table.params['sort_order']).replace();
+                }
+            }
+
+            params = params || {};
+            params.paged = true;
+            params.page = $location.search().page || 1;
+            params['per_page'] = $location.search()['per_page'] || entriesPerPage;
+
+            nutupaneParams = nutupaneParams || {};
+            self.disableAutoLoad = nutupaneParams.disableAutoLoad || false;
+            self.searchKey = action ? action + 'Search' : 'search';
+
+            self.table = {
+                action: action || 'queryPaged',
+                params: params,
+                resource: resource,
+                rows: [],
+                searchTerm: $stateParams[self.searchKey] || $location.search()[self.searchKey] || "",
+                initialLoad: true
+            };
+
+            self.loadParamsFromExistingTable = function (existingTable) {
+                _.extend(params, existingTable.params);
+                if (!self.table.searchTerm) {
+                    self.table.searchTerm = existingTable.searchTerm;
+                }
+            };
+
+            self.load = function () {
+                var deferred = $q.defer(),
+                    resourceCall,
+                    table = self.table,
+                    existingTable = TableCache.getTable(getTableName());
+
+                table.working = true;
+
+                if (table.initialLoad) {
+                    table.refreshing = true;
+                    table.searchCompleted = false;
+                }
+
+                if (existingTable) {
+                    self.loadParamsFromExistingTable(existingTable);
+                }
+
+                params.search = table.searchTerm || "";
+                params.search = self.searchTransform(params.search);
+
+                resourceCall = resource[table.action](params, function (response) {
+                    if (response.error) {
+                        Notification.setErrorMessage(response.error);
+                    }
+
+                    angular.forEach(response.results, function (row) {
+                        row.selected = table.allResultsSelected;
+                    });
+
+                    table.rows = response.results;
+
+                    table.resource.page = parseInt(response.page, 10);
+                    params.page = table.params.page = parseInt(response.page, 10);
+
+                    if (table.initialSelectAll) {
+                        table.selectAll(true);
+                        table.initialSelectAll = false;
+                    }
+
+                    deferred.resolve(response);
+                    table.resource = response;
+                    table.resource.page = parseInt(response.page, 10);
+
+                    if (self.selectAllMode) {
+                        table.selectAll(true);
+                    }
+
+                    if (table.resource.page > 1) {
+                        table.resource.offset = (table.resource.page - 1) * table.resource['per_page'] + 1;
+                    } else {
+                        table.resource.offset = 1;
+                    }
+
+                    TableCache.setTable(getTableName(), table);
+                    setQueryStrings();
+
+                    table.working = false;
+                    table.refreshing = false;
+                    table.initialLoad = false;
+                });
+
+                if (resourceCall && resourceCall.$promise && resourceCall.$promise.catch) {
+                    resourceCall.$promise.catch(function () {
+                        table.working = false;
+                        table.refreshing = false;
+                    });
+                }
+
+                return deferred.promise;
+            };
+
+            self.getParams = function () {
+                return params;
+            };
+
+            self.table.autocomplete = function (term) {
+                var data, promise, localParams;
+
+                if (resource.autocomplete) {
+                    localParams = self.getParams();
+                    localParams.search = term;
+                    data = resource.autocomplete(params);
+                } else {
+                    data = self.table.fetchAutocomplete(term);
+                }
+
+                promise = data.$promise;
+                if (promise) {
+                    return promise.then(function (response) {
+                        return self.table.transformScopedSearch(response);
+                    });
+                }
+
+                return data;
+            };
+
+            self.table.transformScopedSearch = function (results) {
+                var rows = [],
+                    categoriesFound = [];
+                angular.forEach(results, function (row) {
+                    if (row.category && row.category.length > 0) {
+                        if (categoriesFound.indexOf(row.category) === -1) {
+                            categoriesFound.push(row.category);
+                            rows.push({category: row.category, isCategory: true});
+                        }
+                    }
+                    rows.push(row);
+                });
+
+                return rows;
+            };
+
+            //Overridable by real controllers, but default to nothing
+            self.table.fetchAutocomplete = function () {
+                return [];
+            };
+
+            self.enableSelectAllResults = function () {
+                self.table.selectAllResultsEnabled = true;
+                self.table.allResultsSelected = false;
+            };
+
+            self.setParams = function (newParams) {
+                params = newParams;
+            };
+
+            self.addParam = function (param, value) {
+                params[param] = value;
+            };
+
+            self.searchTransform = function (term) {
+                return term;
+            };
+
+            self.query = function () {
+                var table = self.table;
+                if (table.rows.length === 0) {
+                    table.resource.page = 0;
+                }
+                return self.load();
+            };
+
+            self.refresh = function () {
+                var promise, existingTable;
+                existingTable = TableCache.getTable(getTableName());
+
+                if (existingTable) {
+                    self.loadParamsFromExistingTable(existingTable);
+                }
+
+                self.table.refreshing = true;
+                self.table.numSelected = 0;
+                promise = self.load();
+                promise.then(function () {
+                    self.table.selectAllResults(false);
+                });
+                return promise;
+            };
+
+            self.invalidate = function () {
+                TableCache.removeTable(getTableName());
+            };
+
+            self.removeRow = function (id, field) {
+                var foundItem, table = self.table;
+
+                field = field || 'id';
+
+                angular.forEach(table.rows, function (item) {
+                    if (item[field] === id) {
+                        foundItem = item;
+                    }
+                });
+
+                table.rows = _.reject(table.rows, function (item) {
+                    return item[field] === id;
+                }, this);
+
+                table.resource.total = table.resource.total - 1;
+                table.resource.subtotal = table.resource.subtotal - 1;
+                if (foundItem && foundItem.selected) {
+                    table.numSelected = table.numSelected - 1;
+                }
+
+                return self.table.rows;
+            };
+
+            self.getAllSelectedResults = function (identifier) {
+                var selected, selectedRows;
+                identifier = identifier || 'id';
+                selected = {
+                    included: {
+                        ids: [],
+                        resources: [],
+                        search: null,
+                        params: params
+                    },
+                    excluded: {
+                        ids: []
+                    }
+                };
+
+                if (self.table.allResultsSelected) {
+                    selected.included.search = self.table.searchTerm || '';
+                    selected.excluded.ids = _.map(self.getDeselected(), identifier);
+                } else {
+                    selectedRows = self.table.getSelected();
+                    selected.included.ids = _.map(selectedRows, identifier);
+                    selected.included.resources = selectedRows;
+                }
+                return selected;
+            };
+
+            self.getDeselected = function () {
+                var deselectedRows = [];
+                angular.forEach(self.table.rows, function (row, rowIndex) {
+                    if (row.selected !== true) {
+                        deselectedRows.push(self.table.rows[rowIndex]);
+                    }
+                });
+                return deselectedRows;
+            };
+
+            self.table.search = function (searchTerm) {
+                $location.search(self.searchKey, searchTerm);
+                self.table.searchTerm = searchTerm;
+                self.table.resource.page = 1;
+                self.table.params.page = 1;
+                self.table.rows = [];
+                self.table.selectAllResults(false);
+
+                if (!self.table.working) {
+                    self.table.refreshing = true;
+                    if (searchTerm) {
+                        self.table.searchCompleted = true;
+                    } else {
+                        self.table.searchCompleted = false;
+                    }
+                    self.query();
+                }
+            };
+
+            self.table.clearSearch = function () {
+                self.table.search(null);
+                self.table.searchCompleted = true;
+            };
+
+            self.table.replaceRow = function (row) {
+                var index, selected;
+                index = null;
+                angular.forEach(self.table.rows, function (item, itemIndex) {
+                    if (item.id === row.id) {
+                        index = itemIndex;
+                        selected = item.selected;
+                    }
+                });
+
+                if (index >= 0) {
+                    row.selected = selected; //Preserve selectedness
+                    self.table.rows[index] = row;
+                }
+            };
+
+            self.table.addRow = function (row) {
+                self.table.rows.unshift(row);
+                self.table.resource.subtotal += 1;
+                self.table.resource.total += 1;
+            };
+
+            self.table.hasPagination = function () {
+                return self.table.resource && self.table.resource.subtotal && self.table.resource.page &&
+                    self.table.resource.per_page && self.table.resource.offset;
+            };
+
+            self.table.onFirstPage = function () {
+                return self.table.resource.page === 1;
+            };
+
+            self.table.getLastPage = function () {
+                return Math.ceil(self.table.resource.subtotal / self.table.resource.per_page);
+            };
+
+            self.table.onLastPage = function () {
+                return self.table.resource.page >= self.table.getLastPage();
+            };
+
+            self.table.pageExists = function (pageNumber) {
+                return (pageNumber >= 1) && (pageNumber <= self.table.getLastPage());
+            };
+
+            self.table.getPageStart = function () {
+                var table = self.table, pageStart = 0;
+
+                if (table.rows.length > 0) {
+                    pageStart = table.resource.offset;
+                }
+
+                return pageStart;
+            };
+
+            self.table.getPageEnd = function () {
+                var table = self.table, pageEnd;
+
+                pageEnd = table.resource.offset + table.rows.length - 1;
+
+                if (pageEnd > table.resource.subtotal) {
+                    pageEnd = table.resource.subtotal;
+                }
+
+                return pageEnd;
+            };
+
+            self.table.firstPage = function () {
+                return self.table.changePage(1);
+            };
+
+            self.table.previousPage = function () {
+                var previousPage = parseInt(params.page, 10) - 1;
+                return self.table.changePage(previousPage);
+            };
+
+            self.table.nextPage = function () {
+                var nextPage = parseInt(params.page, 10) + 1;
+                return self.table.changePage(nextPage);
+            };
+
+            self.table.lastPage = function () {
+                var table = self.table;
+                return table.changePage(self.table.getLastPage());
+            };
+
+            self.table.changePage = function (pageNumber) {
+                if (pageNumber && self.table.pageExists(pageNumber)) {
+                    self.invalidate();
+                    params.page = pageNumber;
+                    self.table.resource.page = pageNumber;
+                    return self.load();
+                }
+            };
+
+            self.table.pageSizes = _.uniq(_([25, 50, 75, 100, entriesPerPage]).sortBy().value());
+
+            self.table.updatePageSize = function () {
+                params.page = 1;
+                self.query();
+            };
+
+            // Wraps the table.selectAll() function if selectAllResultsEnabled is not set
+            // Otherwise provides expanded functionality
+
+            self.table.selectAllResults = function (selectAll) {
+                if (self.table.allSelected() || selectAll !== 'undefined') {
+                    self.table.selectAll(selectAll);
+                } else if (selectAll) {
+                    self.table.initialSelectAll = true;
+                }
+
+                if (self.table.selectAllResultsEnabled) {
+                    if (selectAll) {
+                        self.table.disableSelectAll();
+                    } else {
+                        self.table.enableSelectAll();
+                    }
+
+                    self.table.allResultsSelected = selectAll;
+                    self.table.numSelected = selectAll ? self.table.resource.subtotal : 0;
+                }
+            };
+
+            self.table.allResultsSelectCount = function () {
+                return self.table.resource.subtotal - self.getDeselected().length;
+            };
+
+            self.table.sortBy = function (column) {
+                if (!column) {
+                    return;
+                }
+                if (column.id) {
+                    params["sort_by"] = column.id;
+                }
+                if (column.id === params["sort_by"] || column.id) {
+                    params["sort_order"] = (params["sort_order"] === 'ASC') ? 'DESC' : 'ASC';
+                } else {
+                    params["sort_order"] = 'ASC';
+                }
+
+                column.sortOrder = params["sort_order"];
+                column.active = true;
+                self.table.rows = [];
+                self.query();
+            };
+
+            self.setSearchKey = function (newKey) {
+                self.searchKey = newKey;
+                self.table.searchTerm = $location.search()[self.searchKey];
+            };
+
+            if (!self.disableAutoLoad) {
+                self.load();
+            }
+        };
+
+        return Nutupane;
+    }]
+);