katello 3.11.2 → 3.12.0.rc1

data/engines/bastion/app/assets/javascripts/bastion/components/bst-form-group.directive.js

@@ -0,0 +1,74 @@
+/**
+ * @ngdoc directive
+ * @name Bastion.components.directive:bstFormGroup
+ *
+ * @description
+ *  Encapsulates the structure and styling for a label + input used within a
+ *  Bootstrap3 based form.
+ *
+ * @example
+ *  <div bst-form-group label="{{ 'Name' | translate }}" required>
+        <input id="name"
+               name="name"
+               ng-model="product.name"
+               type="text"
+               tabindex="1"
+               required/>
+    </div>
+ */
+angular.module('Bastion.components').directive('bstFormGroup', function () {
+    function getInput(element) {
+        // table is used for bootstrap3 date/time pickers
+        var input = element.find('table');
+
+        if (input.length === 0) {
+            input = element.find('input');
+
+            if (input.length === 0) {
+                input = element.find('select');
+
+                if (input.length === 0) {
+                    input = element.find('textarea');
+                }
+            }
+        }
+        return input;
+    }
+
+    return {
+        transclude: true,
+        replace: true,
+        require: '^form',
+        templateUrl: 'components/views/bst-form-group.html',
+        scope: {
+            'label': '@',
+            'field': '@'
+        },
+        link: function (scope, iElement, iAttrs, controller) {
+            var input = getInput(iElement),
+                type = input.attr('type'),
+                field;
+
+            if (!scope.field) {
+                scope.field = input.attr('id');
+            }
+            field = scope.field;
+
+            if (['checkbox', 'radio', 'time'].indexOf(type) === -1) {
+                input.addClass('form-control');
+            }
+
+            if (input.attr('required')) {
+                iElement.addClass('required');
+            }
+
+            if (controller[field]) {
+                scope.error = controller[field].$error;
+            }
+
+            scope.hasErrors = function () {
+                return controller[field] && controller[field].$invalid && controller[field].$dirty;
+            };
+        }
+    };
+});

data/engines/bastion/app/assets/javascripts/bastion/components/bst-menu.directive.js

@@ -0,0 +1,56 @@
+/**
+ * @ngdoc directive
+ * @name Bastion.components.directive:bstMenu
+ * @restrict EA
+ * @requires $window
+ *
+ * @description
+ *   Provides a menu.
+ */
+angular.module('Bastion.components').directive('bstMenu', ['$window', function ($window) {
+    return {
+        restrict: 'EA',
+        replace: true,
+        scope: {
+            'menu': '=bstMenu',
+            'compact': '@'
+        },
+        templateUrl: 'components/views/bst-menu.html',
+        controller: ['$scope', function ($scope) {
+            $scope.dropdown = {};
+
+            $scope.handleHover = function (item, mousein) {
+                if (item.type === 'dropdown' && mousein) {
+                    item.active = true;
+                    $scope.dropdown = item.items;
+                    $scope.dropdown.show = true;
+                    $scope.dropdown.direction = $scope.menu.location;
+                } else {
+                    $scope.dropdown.show = false;
+
+                    if (item !== $scope.menu.activeItem) {
+                        item.active = false;
+                    }
+                }
+            };
+
+        }],
+        link: function (scope, element, attrs) {
+            var elementOriginalOffset;
+
+            if (angular.isDefined(attrs.compact)) {
+                elementOriginalOffset = angular.element(element).offset().top;
+
+                angular.element($window).bind('scroll', function () {
+                    var windowScrollTop = angular.element($window).scrollTop();
+
+                    if (windowScrollTop > elementOriginalOffset + 2) {
+                        element.parent().addClass('compact');
+                    } else if (windowScrollTop < elementOriginalOffset) {
+                        element.parent().removeClass('compact');
+                    }
+                });
+            }
+        }
+    };
+}]);

data/engines/bastion/app/assets/javascripts/bastion/components/bst-modal.directive.js

@@ -0,0 +1,69 @@
+/**
+ * @ngdoc directive
+ * @name Bastion.components.directive:bstModal
+ * @restrict A
+ *
+ * @requires $templateCache
+ * @requires $uibModal
+ *
+ * @description
+ *   Provides a wrapper around angular-ui's modal dialog service.
+ */
+angular.module('Bastion.components').directive('bstModal',
+    ['$templateCache', '$uibModal', function ($templateCache, $uibModal) {
+    return {
+        scope: {
+            action: '&bstModal',
+            modelName: '@model',
+            model: '=',
+            templateUrl: '@'
+        },
+        compile: function(tElement, tAttrs) {
+            var template = angular.element('<div extend-template="components/views/bst-modal.html"></div>'),
+                templateUrl = tAttrs.templateUrl;
+
+            if (!templateUrl) {
+                template.append(tElement.children());
+                tElement.html('');
+                tElement = angular.element(template);
+
+                templateUrl = 'bstModal%d.html'.replace('%d', Math.random().toString());
+                $templateCache.put(templateUrl, tElement);
+            }
+
+            return function (scope) {
+                var modalInstance, modalController;
+
+                modalController = ['$scope', '$uibModalInstance', 'model', function ($scope, $uibModalInstance, model) {
+                    $scope[scope.modelName] = model;
+
+                    $scope.ok = function () {
+                        $uibModalInstance.close();
+                    };
+
+                    $scope.cancel = function () {
+                        $uibModalInstance.dismiss('cancel');
+                    };
+                }];
+
+                scope.openModal = function () {
+                    modalInstance = $uibModal.open({
+                        templateUrl: templateUrl,
+                        controller: modalController,
+                        resolve: {
+                            model: function () {
+                                return scope.model;
+                            }
+                        }
+                    });
+
+                    modalInstance.result.then(function () {
+                        scope.action();
+                    });
+                };
+
+                scope.$parent.openModal = scope.openModal;
+            };
+        }
+    };
+}]);

data/engines/bastion/app/assets/javascripts/bastion/components/bst-on-enter.directive.js

@@ -0,0 +1,29 @@
+(function () {
+    'use strict';
+
+    /**
+     * @ngdoc directive
+     * @name  Bastion.components.directive:bstOnEnter
+     *
+     * @description
+     *   Allows setting an action to be performed when the user presses the enter button.
+     */
+    function bstOnEnter() {
+        return {
+            scope: true,
+            link: function (scope, element, attrs) {
+                element.bind('keydown keypress', function (event) {
+                    if (event.which === 13) {
+                        scope.$apply(attrs.bstOnEnter);
+                        event.preventDefault();
+                    }
+                });
+            }
+        };
+    }
+
+    angular
+        .module('Bastion.components')
+        .directive('bstOnEnter', bstOnEnter);
+
+})();

data/engines/bastion/app/assets/javascripts/bastion/components/bst-resource-switcher.directive.js

@@ -0,0 +1,72 @@
+(function () {
+    'use strict';
+
+    /**
+     * @ngdoc directive
+     * @name Bastion.components.directive:bstResourceSwitcher
+     *
+     * @description
+     *   Allows switching between resources on the same level.
+     */
+    function bstResourceSwitcher($breadcrumb, $location, $state, TableCache) {
+        function getTableName(url) {
+            var tableName = url.split('/');
+
+            if (isFinite(parseInt(tableName[tableName.length - 1], 10))) {
+                tableName.pop();
+            }
+
+            return tableName.join('-').slice(1);
+        }
+
+        return {
+            templateUrl: 'components/views/bst-resource-switcher.html',
+            link: function (scope) {
+                var breadcrumbs = $breadcrumb.getStatesChain(), listUrl, unregisterWatcher;
+                scope.table = {rows: []};
+
+                if (breadcrumbs.length > 0) {
+                    listUrl = breadcrumbs[breadcrumbs.length - 2].ncyBreadcrumbLink;
+                    scope.table = TableCache.getTable(getTableName(listUrl));
+                }
+
+                scope.showSwitcher = function () {
+                    var tableHasRows, isNewPage, hideSwitcher;
+                    // Must have at least two items to switch between them
+                    tableHasRows = scope.table && scope.table.rows.length > 1;
+                    hideSwitcher = scope.hideSwitcher;
+                    // Don't show the switcher when creating a new product
+                    isNewPage = /new$/.test($location.path());
+
+                    return tableHasRows && !isNewPage && !hideSwitcher;
+                };
+
+                scope.changeResource = function (id) {
+                    var currentUrl, nextUrl;
+                    currentUrl = $location.path();
+                    nextUrl = currentUrl.replace(/\d+([^\d+]*)$/, id + '$1');
+                    $location.path(nextUrl);
+                };
+
+                unregisterWatcher = scope.$watch('table.rows', function (rows) {
+                    var currentId = $location.path().match(/\d+/) ? parseInt($location.path().match(/\d+/)[0], 10) : null;
+
+                    angular.forEach(rows, function (row) {
+                        if (row.id === currentId) {
+                            row.selected = true;
+                        } else {
+                            row.selected = false;
+                        }
+                    });
+
+                    unregisterWatcher();
+                });
+            }
+        };
+    }
+
+    angular.module('Bastion.components').directive('bstResourceSwitcher', bstResourceSwitcher);
+
+    bstResourceSwitcher.$inject = ['$breadcrumb', '$location', '$state', 'TableCache'];
+
+})();

data/engines/bastion/app/assets/javascripts/bastion/components/bst-save-control.directive.js

@@ -0,0 +1,29 @@
+/**
+ * @ngdoc directive
+ * @name Bastion.components.directive:bstSaveControl
+ *
+ * @description
+ *   Simple directive for encapsulating create and cancel buttons. This includes states
+ *   for disabling buttons and setting a visual working state.
+ *
+ * @example
+ *   <pre>
+ *     <div bst-save-control
+ *          on-cancel="closeItem()"
+ *          on-save="save(product)"
+ *          invalid="productForm.$invalid">
+ *     </div>
+ */
+angular.module('Bastion.components').directive('bstSaveControl', function () {
+    return {
+        restrict: 'AE',
+        replace: true,
+        templateUrl: 'components/views/bst-save-control.html',
+        scope: {
+            handleSave: '&onSave',
+            handleCancel: '&onCancel',
+            invalid: '=',
+            working: '='
+        }
+    };
+});

data/engines/bastion/app/assets/javascripts/bastion/components/bst-table.directive.js

@@ -0,0 +1,337 @@
+/**
+ * @ngdoc directive
+ * @name Bastion.components.directive:bstTable
+ * @restrict A
+ *
+ * @requires $window
+ *
+ * @description
+ *
+ * @example
+ */
+angular.module('Bastion.components')
+    .directive('bstTable', function () {
+        return {
+            restrict: 'A',
+            replace: true,
+            scope: {
+                'table': '=bstTable',
+                'rowSelect': '@',
+                'rowChoice': '@'
+            },
+            controller: 'BstTableController',
+            link: function (scope, element) {
+                function checkForResults(rows) {
+                    var table = scope.table,
+                        tableElement = element.find('table'),
+                        tableBody = tableElement.find('tbody'),
+                        existingTr, numberOfColumns, messageTd, message;
+
+                    tableBody.find('#noRowsTr').remove();
+
+                    if (rows.length === 0 && !table.working) {
+                        existingTr = tableBody.find('#noRowsTr');
+                        numberOfColumns = tableElement.find('th').length;
+
+                        if (table.searchTerm || table.searchCompleted) {
+                            message = element.find("#noSearchResultsMessage").html();
+                        } else {
+                            message = element.find("#noRowsMessage").html();
+                        }
+
+                        messageTd = $('<td>').attr('colspan', numberOfColumns);
+                        messageTd.html(message);
+
+                        if (existingTr.length > 0) {
+                            existingTr.html(messageTd);
+                        } else {
+                            tableBody.append($('<tr id="noRowsTr">'));
+                            tableBody.find('tr').html(messageTd);
+                        }
+
+                    }
+                }
+
+                // Check for results and handle no rows message
+                scope.$watch('table.rows', checkForResults);
+            }
+        };
+    })
+    .controller('BstTableController', ['$scope', function ($scope) {
+        var rows = $scope.rows = [],
+            headers = $scope.headers = [],
+            self = this;
+
+        this.selection = {allSelected: false, selectAllDisabled: false};
+
+        if (!$scope.table.numSelected) {
+            $scope.table.numSelected = 0;
+        }
+
+        $scope.table.chosenRow = null;
+
+        $scope.table.getSelected = function () {
+            var selectedRows = [];
+            angular.forEach($scope.table.rows, function (row, rowIndex) {
+                if (row.selected === true) {
+                    selectedRows.push($scope.table.rows[rowIndex]);
+                }
+            });
+            return selectedRows;
+        };
+
+        $scope.table.selectAllDisabled = false;
+
+        this.disableSelectAll = $scope.table.disableSelectAll = function () {
+            self.selection.selectAllDisabled = true;
+        };
+
+        this.enableSelectAll = $scope.table.enableSelectAll = function () {
+            self.selection.selectAllDisabled = false;
+        };
+
+        $scope.table.allSelected = function () {
+            return self.selection.allSelected;
+        };
+
+        this.addRow = function (row) {
+            rows.push(row);
+
+            if (headers.length) {
+                angular.forEach(headers[0].columns, function (column, columnIndex) {
+                    if (row.cells[columnIndex]) {
+                        row.cells[columnIndex].show = column.show;
+                    }
+                });
+            }
+        };
+
+        this.addHeader = function (columns) {
+            headers.push(columns);
+        };
+
+        this.itemSelected = function (row) {
+            $scope.table.numSelected += row.selected ? 1 : -1;
+            self.selection.allSelected = false;
+        };
+
+        this.itemChosen = function (row) {
+            $scope.table.chosenRow = row;
+        };
+
+        this.selectAll = $scope.table.selectAll = function (selected) {
+            var table = $scope.table,
+                rowsSelected = 0;
+
+            self.selection.allSelected = selected;
+            angular.forEach(table.rows, function (row) {
+                if (!row.unselectable) {
+                    row.selected = self.selection.allSelected;
+                    rowsSelected = rowsSelected + 1;
+                }
+            });
+            $scope.table.numSelected = selected ? rowsSelected : 0;
+        };
+
+    }])
+    .directive('bstTableHead', [function () {
+        var rowSelectTemplate = function () {
+            return '<th class="row-select">' +
+                      '<input type="checkbox"' +
+                              'ng-model="selection.allSelected"' +
+                              'ng-disabled="selection.selectAllDisabled"' +
+                              'ng-change="allSelected()">' +
+                    '</th>';
+        }, rowChoiceTemplate = function () {
+            return '<th translate class="row-select"></th>';
+        };
+
+        return {
+            require: '^bstTable',
+            restrict: 'A',
+            scope: true,
+            controller: 'BstTableHeadController',
+            compile: function (tElement, tAttrs) {
+                if (angular.isDefined(tAttrs.rowSelect)) {
+                    tElement.prepend(rowSelectTemplate());
+                } else if (angular.isDefined(tAttrs.rowChoice)) {
+                    tElement.prepend(rowChoiceTemplate());
+                }
+
+                return function (scope, element, attrs, bstTableController) {
+                    if (angular.isDefined(tAttrs.rowSelect) && angular.isDefined(scope.table)) {
+                        scope.table.rowSelect = true;
+                    } else if (angular.isDefined(tAttrs.rowChoice)) {
+                        scope.table.rowChoice = true;
+                    }
+
+                    bstTableController.addHeader(scope.header);
+
+                    scope.selection = bstTableController.selection;
+
+                    scope.allSelected = function () {
+                        bstTableController.selectAll(scope.selection.allSelected);
+                    };
+                };
+            }
+        };
+    }])
+    .controller('BstTableHeadController', ['$scope', function ($scope) {
+        $scope.header = {
+            columns: []
+        };
+
+        this.addColumn = function (column) {
+            $scope.header.columns.push(column);
+        };
+    }])
+    .directive('bstTableColumn', ['$compile', function ($compile) {
+        var sortIconTemplate = '<th ng-click="table.sortBy(column)">' +
+                                  '<i class="sort-icon" ng-show="table.resource.sort.by == column.id" ng-class="{\'fa fa-sort-down\': column.sortOrder == \'DESC\', \'fa fa-sort-up\': column.sortOrder == \'ASC\'}"></i>' +
+                               '</th>';
+        return {
+            require: '^bstTableHead',
+            restrict: 'A',
+            scope: true,
+            controller: ['$scope', function ($scope) {
+                $scope.column = { show: true };
+            }],
+            compile: function (tElement, tAttributes) {
+                var newElement;
+
+                if (tAttributes.hasOwnProperty("sortable")) {
+                    newElement = angular.element(sortIconTemplate);
+                    newElement.find('.sort-icon').before(tElement.html());
+                    newElement.addClass('sortable');
+                    newElement.addClass(tElement.attr('class'));
+                    tElement.replaceWith(newElement);
+                }
+                return function (scope, element, attributes, bstTableHeadController) {
+                    if (attributes.hasOwnProperty("sortable")) {
+                        $compile(element)(scope);
+                    }
+                    scope.column.id = attributes.bstTableColumn;
+                    bstTableHeadController.addColumn(scope.column);
+
+                    scope.$watch('column.show', function (show) {
+                        var display = show ? '' : 'none';
+                        element.css('display', display);
+                    });
+                };
+            }
+        };
+    }])
+    .directive('bstTableRow', ['$parse', function ($parse) {
+        var rowSelectTemplate, rowChoiceTemplate, activeRowTemplate;
+
+        rowSelectTemplate = function (model) {
+            return '<td class="row-select">' +
+                      '<input type="checkbox"' +
+                              'ng-model="' + model + '.selected"' +
+                              'ng-disabled="' + model + '.unselectable"' +
+                              'ng-change="itemSelected(' + model + ')">' +
+                   '</td>';
+        };
+
+        rowChoiceTemplate = function (model) {
+            return '<td class="row-choice">' +
+                      '<input type="radio"' +
+                              'ng-model="table.chosenRow"' +
+                              'ng-value="' + model + '"' +
+                              'ng-click="itemChosen(' + model + ')">' +
+                   '</td>';
+        };
+
+        activeRowTemplate = function (activeTest) {
+            return '<i class="fa fa-chevron-right selected-icon" ' +
+                   'ng-show="' + activeTest + ' "></i>';
+        };
+
+        return {
+            require: '^bstTable',
+            restrict: 'A',
+            scope: true,
+            controller: 'BstTableRowController',
+            compile: function (tElement, tAttrs) {
+
+                if (angular.isDefined(tAttrs.activeRow)) {
+                    tElement.find('td:first-child').append(activeRowTemplate(tAttrs.activeRow));
+                }
+
+                if (angular.isDefined(tAttrs.rowSelect)) {
+                    tElement.prepend(rowSelectTemplate(tAttrs.rowSelect));
+                }
+
+                if (angular.isDefined(tAttrs.rowChoice)) {
+                    tElement.prepend(rowChoiceTemplate(tAttrs.rowChoice));
+                }
+
+                if (angular.isDefined(tAttrs.activeRow)) {
+                    tElement.find('td').attr('ng-class', '{ "active-row": ' + tAttrs.activeRow + ' }');
+                }
+
+                return function (scope, element, attrs, bstTableController) {
+                    bstTableController.addRow(scope.row);
+
+                    if (attrs.rowSelect) {
+                        scope.model = $parse(attrs.rowSelect)(scope);
+
+                        if ($parse(attrs.rowSelectIf)(scope)) {
+                            scope.model.unselectable = true;
+                        }
+
+                        scope.$watch('model.selected', function (selected) {
+                            if (selected) {
+                                element.addClass('selected-row');
+                            } else {
+                                element.removeClass('selected-row');
+                            }
+                        });
+                    } else if (attrs.rowChoice) {
+                        scope.model = $parse(attrs.rowChoice)(scope);
+                    }
+
+                    if (attrs.activeRow) {
+                        scope.activeTest = $parse(attrs.activeRow)(scope);
+                    }
+
+                    scope.itemSelected = function (row) {
+                        bstTableController.itemSelected(row);
+                    };
+
+                    scope.itemChosen = function (row) {
+                        element.parent().find('.selected-row').removeClass('selected-row');
+                        element.addClass('selected-row');
+                        bstTableController.itemChosen(row);
+                    };
+                };
+            }
+        };
+    }])
+    .controller('BstTableRowController', ['$scope', function ($scope) {
+        $scope.row = {
+            cells: []
+        };
+
+        this.addCell = function (cell) {
+            $scope.row.cells.push(cell);
+        };
+    }])
+    .directive('bstTableCell', [function () {
+        return {
+            require: '^bstTableRow',
+            restrict: 'A',
+            scope: true,
+            controller: ['$scope', function ($scope) {
+                $scope.cell = { show: true };
+            }],
+            link: function (scope, element, attrs, bstTableRowController) {
+                bstTableRowController.addCell(scope.cell);
+
+                scope.$watch('cell.show', function (show) {
+                    var display = show ? '' : 'none';
+                    element.css('display', display);
+                });
+            }
+        };
+    }]);