bastion 0.1.0

data/app/assets/javascripts/bastion/menu/menu.module.js

@@ -0,0 +1,26 @@
+/**
+ * Copyright 2014 Red Hat, Inc.
+ *
+ * This software is licensed to you under the GNU General Public
+ * License as published by the Free Software Foundation; either version
+ * 2 of the License (GPLv2) or (at your option) any later version.
+ * There is NO WARRANTY for this software, express or implied,
+ * including the implied warranties of MERCHANTABILITY,
+ * NON-INFRINGEMENT, or FITNESS FOR A PARTICULAR PURPOSE. You should
+ * have received a copy of GPLv2 along with this software; if not, see
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.txt.
+ */
+
+/**
+ * @ngdoc module
+ * @name  Bastion.menu
+ *
+ * @description
+ *   Module for menu related functionality.
+ */
+angular.module('Bastion.menu', [
+    'alchemy',
+    'alch-templates',
+    'Bastion',
+    'Bastion.widgets'
+]);

data/app/assets/javascripts/bastion/utils/as.filter.js

@@ -0,0 +1,33 @@
+/**
+ * Copyright 2014 Red Hat, Inc.
+ *
+ * This software is licensed to you under the GNU General Public
+ * License as published by the Free Software Foundation; either version
+ * 2 of the License (GPLv2) or (at your option) any later version.
+ * There is NO WARRANTY for this software, express or implied,
+ * including the implied warranties of MERCHANTABILITY,
+ * NON-INFRINGEMENT, or FITNESS FOR A PARTICULAR PURPOSE. You should
+ * have received a copy of GPLv2 along with this software; if not, see
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.txt.
+ **/
+
+/**
+ * @ngdoc filter
+ * @name Bastion.utils.filter:as
+ *
+ * @requires $parse
+ *
+ * @description
+ *   Adds variable to scope with the value passed in. This allows adding to the
+ *   scope a variable that contains the result of multiple applied filters.
+ *
+ * @example
+ *   <ul>
+       <li ng-repeat="item in items | filter:customFilter | as:filteredItems"></li>
+     </ul>
+ */
+angular.module('Bastion.utils').filter('as', ['$parse', function ($parse) {
+    return function (value, path) {
+        return $parse(path).assign(this, value);
+    };
+}]);

data/app/assets/javascripts/bastion/utils/form-utils.service.js

@@ -0,0 +1,53 @@
+/**
+ * Copyright 2014 Red Hat, Inc.
+ *
+ * This software is licensed to you under the GNU General Public
+ * License as published by the Free Software Foundation; either version
+ * 2 of the License (GPLv2) or (at your option) any later version.
+ * There is NO WARRANTY for this software, express or implied,
+ * including the implied warranties of MERCHANTABILITY,
+ * NON-INFRINGEMENT, or FITNESS FOR A PARTICULAR PURPOSE. You should
+ * have received a copy of GPLv2 along with this software; if not, see
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.txt.
+ **/
+
+/**
+ * @ngdoc service
+ * @name Bastion.service.directive:FormUtils
+ *
+ * @requires uuid4
+ *
+ * @description
+ *   A set of utilities that are useful when using forms.
+ */
+angular.module('Bastion.utils').service('FormUtils', ['uuid4', function (uuid4) {
+    var regex = new RegExp("[^a-z0-9\\-_]", 'gi'),
+        replacement = "_",
+        isASCII;
+
+    /**
+     * @ngdoc function
+     * @name Bastion.service.FormUtils#labelize
+     * @methodOf Bastion.service.FormUtils
+     * @function
+     *
+     * @description
+     *   Turns a resource's name attribute into a labelized value.
+     *
+     * @param {Resource} resource An object representing a resource entity with a name property
+     * @returns {Bastion.service.FormUtils} Self for chaining.
+     */
+    this.labelize = function (resource) {
+        if (resource.name) {
+            resource.label = (isASCII(resource.name) && resource.name.length <= 128) ?
+                resource.name.replace(regex, replacement) : uuid4.generate();
+        }
+
+        return this;
+    };
+
+    isASCII = function isASCII(str) {
+        return (/^[\x00-\x7F]*$/).test(str);
+    };
+
+}]);

data/app/assets/javascripts/bastion/utils/utils.module.js

@@ -0,0 +1,21 @@
+/**
+ Copyright 2014 Red Hat, Inc.
+
+ This software is licensed to you under the GNU General Public
+ License as published by the Free Software Foundation; either version
+ 2 of the License (GPLv2) or (at your option) any later version.
+ There is NO WARRANTY for this software, express or implied,
+ including the implied warranties of MERCHANTABILITY,
+ NON-INFRINGEMENT, or FITNESS FOR A PARTICULAR PURPOSE. You should
+ have received a copy of GPLv2 along with this software; if not, see
+ http://www.gnu.org/licenses/old-licenses/gpl-2.0.txt.
+ **/
+
+/**
+ * @ngdoc module
+ * @name  Bastion.utils
+ *
+ * @description
+ *   Module for common utilities.
+ */
+angular.module('Bastion.utils', ['Bastion', 'uuid4']);

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

@@ -0,0 +1,67 @@
+/**
+ Copyright 2014 Red Hat, Inc.
+
+ This software is licensed to you under the GNU General Public
+ License as published by the Free Software Foundation; either version
+ 2 of the License (GPLv2) or (at your option) any later version.
+ There is NO WARRANTY for this software, express or implied,
+ including the implied warranties of MERCHANTABILITY,
+ NON-INFRINGEMENT, or FITNESS FOR A PARTICULAR PURPOSE. You should
+ have received a copy of GPLv2 along with this software; if not, see
+ http://www.gnu.org/licenses/old-licenses/gpl-2.0.txt.
+ **/
+
+/**
+ * @ngdoc directive
+ * @name Bastion.widgets.directive:currentTasks
+ *
+ * @requires $document
+ * @requires CurrentUser
+ * @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.widgets').directive('currentTasks',
+    ['$document', 'CurrentUser', 'Task',
+    function ($document, CurrentUser, Task) {
+
+        return {
+            restrict: 'A',
+            scope: true,
+            templateUrl: 'widgets/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 = CurrentUser;
+                $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) {
+                Task.registerSearch({ 'active_only': true, 'type': 'user', 'user_id': CurrentUser.id}, scope.updateTasks);
+            }
+        };
+    }]);

data/app/assets/javascripts/bastion/widgets/nutupane-table.directive.js

@@ -0,0 +1,59 @@
+/**
+ * @ngdoc directive
+ * @name Bastion.components.directive:nutupaneTable
+ * @restrict A
+ *
+ * @require $compile
+ *
+ * @description
+ *
+ * @example
+ */
+angular.module('alchemy').directive('nutupaneTable', ['$compile', function ($compile) {
+    return {
+        restrict: 'A',
+        link: function (scope, element) {
+            var originalTable, clonedTable, clonedThs;
+
+            scope.$on("$stateChangeSuccess", function (event, newState, newParams, oldState) {
+                // Only clone the table if the collapsed value changed or it's the first time.
+                if (newState.collapsed !== oldState.collapsed || !oldState.name) {
+                    buildTable();
+                } else {
+                    element.find("table:not(.cloned-nutupane-table)").find('thead').hide();
+                }
+            });
+
+            function buildTable() {
+                element.find('.cloned-nutupane-table').remove();
+
+                originalTable = element.find('table');
+                clonedTable = originalTable.clone();
+
+                clonedTable.removeAttr("nutupane-table");
+                clonedTable.addClass("cloned-nutupane-table");
+                clonedTable.find('tbody').remove();
+
+                originalTable.find('thead').hide();
+
+                element.prepend(clonedTable);
+                $compile(element.find('.cloned-nutupane-table'))(scope);
+
+                // Need to remove duplicate row-select created by second $compile
+                var rowSelect = element.find(".row-select")[0];
+                if (rowSelect) {
+                    angular.element(rowSelect).remove();
+                }
+
+                // Compile each cloned th individually with original th scope
+                // so sort will work.
+                clonedThs = element.find('.cloned-nutupane-table th');
+                angular.forEach(originalTable.find('th'), function (th, index) {
+                    $compile(clonedThs[index])(angular.element(th).scope());
+                });
+            }
+
+            buildTable();
+        }
+    };
+}]);

data/app/assets/javascripts/bastion/widgets/nutupane.factory.js

@@ -0,0 +1,316 @@
+/**
+ * Copyright 2014 Red Hat, Inc.
+ *
+ * This software is licensed to you under the GNU General Public
+ * License as published by the Free Software Foundation; either version
+ * 2 of the License (GPLv2) or (at your option) any later version.
+ * There is NO WARRANTY for this software, express or implied,
+ * including the implied warranties of MERCHANTABILITY,
+ * NON-INFRINGEMENT, or FITNESS FOR A PARTICULAR PURPOSE. You should
+ * have received a copy of GPLv2 along with this software; if not, see
+ * http://www.gnu.org/licenses/old-licenses/gpl-2.0.txt.
+ */
+
+/**
+ * @ngdoc service
+ * @name  Bastion.widgets.service:Nutupane
+ *
+ * @requires $location
+ * @requires $q
+ * @requires $timeout
+ *
+ * @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.widgets').factory('Nutupane',
+    ['$location', '$q', '$timeout', function ($location, $q, $timeout) {
+        var Nutupane = function (resource, params, action) {
+            var self = this;
+            params = params || {};
+
+            self.searchKey = action ? action + 'Search' : 'search';
+
+            self.table = {
+                action: action || 'queryPaged',
+                params: params,
+                resource: resource,
+                rows: [],
+                searchTerm: $location.search()[self.searchKey],
+                initialLoad: true
+            };
+
+            // Set default resource values
+            resource.page = 0;
+            resource.subtotal = "0";
+            resource.total = "0";
+            resource.results = [];
+
+            self.load = function (replace) {
+                var deferred = $q.defer(),
+                    table = self.table;
+
+                replace = replace || false;
+                table.working = true;
+
+                params.page = table.resource.page + 1;
+                params.search = table.searchTerm || "";
+                params.search = self.searchTransform(params.search);
+
+                resource[table.action](params, function (response) {
+
+                    angular.forEach(response.results, function (row) {
+                        row.selected = table.allResultsSelected;
+                    });
+
+                    if (replace) {
+                        table.rows = response.results;
+                    } else {
+                        table.rows = table.rows.concat(response.results);
+                    }
+                    table.resource.page = parseInt(response.page, 10);
+
+                    if (table.initialSelectAll) {
+                        table.selectAll(true);
+                        table.initialSelectAll = false;
+                    }
+
+                    // This $timeout is necessary to cause a digest cycle
+                    // in order to prevent loading two sets of results.
+                    $timeout(function () {
+                        deferred.resolve(response);
+                        table.resource = response;
+                        table.resource.page = parseInt(response.page, 10);
+
+                        if (self.selectAllMode) {
+                            table.selectAll(true);
+                        }
+                        table.resource.offset = table.rows.length;
+                    }, 0);
+                    table.working = false;
+                    table.refreshing = false;
+                });
+
+                return deferred.promise;
+            };
+
+            self.getParams = function () {
+                return params;
+            };
+
+            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 () {
+                self.table.resource.page = 0;
+                return self.load(true);
+            };
+
+            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 = _.pluck(self.getDeselected(), identifier);
+                } else {
+                    selectedRows = self.table.getSelected();
+                    selected.included.ids = _.pluck(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.resource.page = 1;
+                self.table.rows = [];
+                self.table.closeItem();
+                self.table.selectAllResults(false);
+
+                if (!self.table.working) {
+                    self.query(searchTerm);
+                }
+            };
+
+            // Must be overridden
+            self.table.closeItem = function () {
+                throw "NotImplementedError";
+            };
+
+            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.nextPage = function () {
+                var table = self.table;
+                if (table.working || !table.hasMore()) {
+                    return;
+                }
+                return self.query();
+            };
+
+            self.table.hasMore = function () {
+                var length = self.table.rows.length,
+                    subtotal = self.table.resource.subtotal,
+                    hasMore = false;
+
+                if (!subtotal) {
+                    hasMore = false;
+                } else {
+                    var justBegun = (length === 0 && subtotal !== 0);
+                    hasMore = (length < subtotal) || justBegun;
+                }
+                return hasMore;
+            };
+
+            // 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) {
+                var sort = self.table.resource.sort;
+                if (!column) {
+                    return;
+                }
+
+                params["sort_by"] = column.id;
+                if (column.id === sort.by) {
+                    params["sort_order"] = (sort.order === 'ASC') ? 'DESC' : 'ASC';
+                } else {
+                    params["sort_order"] = 'ASC';
+                }
+
+                column.sortOrder = params["sort_order"];
+                column.active = true;
+                self.table.rows = [];
+                self.query();
+            };
+        };
+        return Nutupane;
+    }]
+);