foreman_pipeline 0.0.1

data/app/assets/javascripts/foreman_pipeline/jobs/details/job-details-jenkins.controller.js

@@ -0,0 +1,56 @@
+angular.module('ForemanPipeline.jobs').controller('JobDetailsJenkinsController',
+    ['$scope', '$q', '$location','translate', 'Job', 'JenkinsInstance', 'Nutupane', 
+        function ($scope, $q, $location, translate, Job, JenkinsInstance, Nutupane) {
+
+            $scope.successMessages = [];
+            $scope.errorMessages = [];
+
+            params = {
+                'search': $location.search().search || "",
+                'sort_by': 'name',
+                'sort_order': 'ASC',
+            };
+
+            $scope.job = $scope.job || Job.get({id: $scope.$stateParams.jobId}, function () {
+                $scope.panel.loading = false;
+            });
+
+            var nutupane = new Nutupane(JenkinsInstance, params);
+            $scope.jenkinsTable = nutupane.table;        
+            $scope.nutupane = nutupane;
+            nutupane.query();
+            
+            $scope.setJenkins = function () {
+                var success,
+                    error,
+                    deferred = $q.defer();
+
+                    $scope.chosen = $scope.jenkinsTable.chosenRow;
+                    data = {jenkins_instance_id: $scope.chosen.id};
+
+                    success = function (response) {
+                        deferred.resolve(response);
+                        $scope.successMessages.push(translate('New Jenkins Instance successfully set.'));                        
+                        nutupane.refresh();
+                        $scope.job.jenkins_instance = $scope.chosen;
+                        $scope.jenkinsTable.chosenRow = null;
+                        $scope.jenkinsTable.working = false;
+                    };                 
+
+                    error = function (response) {
+                        deferred.reject(response);
+                        angular.forEach(response.data.errors, function (errorMessage, key) {
+                            if (angular.isString(key)) {
+                                errorMessage = [key, errorMessage].join(' ');
+                            }
+                            $scope.errorMessages.push(translate('Error occured while saving Job: ') + errorMessage);
+                        });
+                        $scope.jenkinsTable.working = false;
+                    };
+
+                    $scope.jenkinsTable.working = true;
+                    Job.setJenkins({id: $scope.job.id}, data, success, error);
+                    return deferred.promise;
+            };          
+        }
+    ]);

data/app/assets/javascripts/foreman_pipeline/jobs/details/job-details-resources.controller.js

@@ -0,0 +1,60 @@
+angular.module('ForemanPipeline.jobs').controller('JobDetailsResourcesController', 
+    ['$scope', '$q', '$location', '$window', 'translate', 'Job', 'Nutupane', 
+        function ($scope, $q, $location, $window, translate, Job, Nutupane) {
+
+            $scope.successMessages = [];
+            $scope.errorMessages = [];        
+
+            params = {
+                'search': $location.search().search || "",
+                'sort_by': 'name',
+                'order': 'ASC',
+                'id': $scope.$stateParams.jobId,
+            };
+
+            $scope.job = $scope.job || Job.get({id: $scope.$stateParams.jobId}, function () {
+                $scope.panel.loading = false;
+            });        
+
+            var nutupane = new Nutupane(Job, params, 'availableResources');
+            $scope.nutupane = nutupane;
+            $scope.table = nutupane.table;
+            nutupane.query();
+
+            $scope.setResource = function () {
+                var success,
+                    error,
+                    deferred = $q.defer();
+
+                $scope.chosen = $scope.table.chosenRow;
+                data = {resource_id: $scope.chosen.id};
+
+                success = function (response) {
+                    deferred.resolve(response);
+                    $scope.successMessages.push(translate('New resource successfully set.'));
+                    $scope.table.working = false;
+                    nutupane.refresh();
+                    $scope.job.compute_resource = $scope.chosen;
+                };
+
+                error = function (response) {
+                    $q.reject(response);
+                    angular.forEach(response.data.errors, function (errorMessage, key) {
+                                if (angular.isString(key)) {
+                                    errorMessage = [key, errorMessage].join(' ');
+                                }
+                                $scope.errorMessages.push(translate('Error occured while saving the Job: ' + errorMessage));
+                            });
+                            $scope.table.working = false;
+                }
+
+                $scope.table.working = true;
+                Job.setResource({id: $scope.job.id}, data, success, error);
+                return deferred.promise;
+            };
+
+            $scope.transitionToResource = function (resource) {
+                $window.location.href = '/compute_resources/' + resource.id 
+            };
+        } 
+]);

data/app/assets/javascripts/foreman_pipeline/jobs/details/job-details-to-environments.controller.js

@@ -0,0 +1,157 @@
+angular.module('ForemanPipeline.jobs').controller('JobDetailsToEnvironmentsController',
+    ['$scope', '$q', 'Job', 'translate', 'CurrentOrganization',
+        function ($scope, $q, Job, translate, CurrentOrganization) {
+
+            $scope.successMessages = [];
+            $scope.errorMessages = [];
+            $scope.environments = [];
+
+            $scope.job = $scope.job || Job.$get({id: $scope.$stateParams.jobId}, function () {
+                $scope.panel.loading = false;
+            });
+
+            var params = {
+                id: $scope.$stateParams.jobId,
+                organization_id: CurrentOrganization,
+            };
+
+            $scope.toEnvironments = $scope.job.to_environments;
+
+            $scope.loading = true;      
+
+            $scope.paths = Job.availableEnvironments(params, function () {
+                $scope.loading = false;
+            });
+
+            $scope.setToEnvironments = function () {
+                var success, 
+                    error,
+                    deferred = $q.defer();                    
+                    data = {to_environment_ids: _.map($scope.toEnvironments, function (env) { return env.id })};
+
+                    success = function (response) {
+                        deferred.resolve(response);
+                        $scope.successMessages.push(translate("New 'to environments' successfully set."))
+                        $scope.working = false;
+                        $scope.job.to_environments = $scope.toEnvironments;
+                    };
+
+                    error = function (response) {
+                        deferred.reject(response);
+                        angular.forEach(response.data.errors, function (errorMessage, key) {
+                            if (angular.isString(key)) {
+                                errorMessage = [key, errorMessage].join(' ');
+                            }
+                            $scope.errorMessages.push(translate('Error occured while saving the Job: ' + errorMessage));
+                        });
+                        $scope.working = false;
+                    };
+
+                    $scope.working = true;
+                    Job.setToEnvironments({id: $scope.job.id}, data, success, error);
+                    return deferred.promise;
+            };
+        }]
+
+).directive('plnPathSelector',
+    function () {
+    return {
+        restrict: 'AE',
+        // templateUrl: 'jobs/views/pln-path-selector.html',
+        // using templateUrl gives me deprecated XMLHttp request from jQuery, perhaps somehow preload and precompile would help?  
+        template: '<div class="path-selector" ng-repeat="path in paths">'+
+                      '<ul class="path-list">'+
+                        '<li class="path-list-item" ng-repeat="item in path" ng-class="{ \'disabled-item\': item.disabled }">'+
+                          '<label class="path-list-item-label" ng-disabled="item.disabled" ng-class="{ active: item.selected }" ng-mouseenter="hover" ng-mouseleave="hover = false">'+
+                            '<input type="checkbox" ng-model="item.selected" ng-change="itemChanged(item)" ng-disabled="item.disabled"/>'+
+                            '{{ item.name }}'+
+                          '</label>'+
+                        '</li>'+
+                      '</ul>'+
+                    '</div>',
+        link: function (scope, element, attrs, ngModel) {
+            var activeItemId;
+            
+            if (scope.paths.$promise) {
+                scope.paths.$promise.then(function (paths) {
+                    scope.paths = convertPathObjects(paths);
+                    itemsLoad();
+                });
+            } else {
+                scope.paths = convertPathObjects(scope.paths);
+                itemsLoad();
+            }
+
+            function forEachInModel(callback){    
+                angular.forEach(scope.toEnvironments, function (modelItem) {
+                    callback(modelItem);
+                });                
+            }
+
+            function forEachItem(callback) {
+                angular.forEach(scope.paths, function (path) {
+                    angular.forEach(path, function (item) {
+                        callback(item);
+                    });
+                });
+            }
+
+            function unselectItem(item) {
+                scope.toEnvironments = _.reject(scope.toEnvironments, function (obj) { return obj.id === item.id });
+            }
+
+            function selectItem(item) {
+                scope.toEnvironments = _.union(scope.toEnvironments, [item]);   
+            }
+
+            scope.itemChanged = function (item) {
+                if (item) {
+                    if (item.selected) {
+                        selectItem(item);
+                    } else {
+                        unselectItem(item);
+                    }
+                }
+            }
+
+            function itemsLoad(){
+                var modelIds = _.pluck(scope.toEnvironments, "id"),
+                    succIds = _.pluck(scope.job.environment.successors, "id");
+                forEachItem(function (item) {
+                    forEachInModel(function (modelItem) {
+                        if (item.id === modelItem.id) {
+                            item.flag = true;
+                        }
+                    });
+                    if (item.selected && !item.flag) {
+                        item.selected = false;                        
+                        modelIds = _.reject(modelIds, function (id) { return id === item.id });
+                    } else if (!item.selected && item.flag) {
+                        item.selected = true;                        
+                        modelIds = _.union(modelIds, [item.id]);
+                    }
+                    item.flag = false;
+                    if (_.indexOf(succIds, item.id) < 0) {
+                        item.disabled = true;
+                    }           
+                });                
+                scope.toEnvironments = [];
+                forEachItem(function (item) {
+                    angular.forEach(modelIds , function (id) {
+                        if (item.id === id ){
+                            scope.toEnvironments.push(item);
+                        }
+                    });
+                });
+            }
+
+            function convertPathObjects(paths) {              
+                if (scope.pathAttribute) {
+                    paths = _.pluck(paths, scope.pathAttribute);
+                }                
+                return paths;
+            }
+
+        }
+    };
+});

data/app/assets/javascripts/foreman_pipeline/jobs/details/job-details.controller.js

@@ -0,0 +1,34 @@
+angular.module('ForemanPipeline.jobs').controller('JobDetailsController',
+    ['$scope', '$state', 'Job', function ($scope, $state, Job) {
+
+        
+        $scope.successMessages = [];
+        $scope.errorMessages = [];
+        $scope.isValid = false;
+
+        if ($scope.job) {
+            $scope.panel = {loading: false};
+        } else {
+            $scope.panel = {loading: true};
+        }
+        
+        $scope.job = Job.get({id: $scope.$stateParams.jobId}, function () {
+            $scope.isValid = $scope.checkValid();
+            $scope.panel.loading = false;
+        });
+
+        $scope.checkValid = function () {
+            return $scope.job.content_view !== null 
+                        && $scope.job.hostgroup !== null
+                        && $scope.job.compute_resource !== null
+                        && $scope.job.jenkins_instance !== null
+                        && $scope.job.environment !== null
+                        && $scope.job.jenkins_user !== null;
+        }
+
+        $scope.$on('envNull', function () {
+            $scope.job.environment = null;
+        });
+
+    }]
+);

data/app/assets/javascripts/foreman_pipeline/jobs/details/project-discovery/job-projects-discovery.controller.js

@@ -0,0 +1,96 @@
+angular.module('ForemanPipeline.jobs').controller('JobProjectsDiscoveryController',
+    ['$scope', '$q', 'translate',  'Job', 'Task', 'JenkinsRequest',
+        function ($scope, $q, translate, Job, Task, JenkinsRequest) {
+
+            var setDetails, transformRows;
+
+            $scope.successMessages = [];
+            $scope.errorMessages = [];
+
+            $scope.projectsTable = {rows: []};
+            $scope.discovery = {pattern: ''}
+
+            updateTask = function (task) {
+                setDetails(task);
+                if (!task.pending) {
+                    Task.unregisterSearch($scope.taskSearchId);
+                }
+            }
+
+            setDetails = function (task) {
+                $scope.discovery.pending = task.pending;
+                if (!task.pending) {
+                    $scope.discovery.pattern = task.input.filter
+                    $scope.projectsTable.rows = transformRows(task.output.projects)
+                }
+            }
+
+            transformRows = function (project_names) {
+                var projects, sorted;
+                projects = _.map(project_names, function (item) {
+                    return {'name': item}
+                });
+                
+                sorted = _.sortBy(projects, function (item) {
+                    return item.name;
+                });
+
+                return _.filter(sorted, function (obj) {
+                    return !_.findWhere($scope.job.jenkins_projects, obj);
+                });
+            }
+
+            registerTask = function (task) {
+                $scope.taskSearchId = Task.registerSearch({'type': 'task', 'task_id': task.id }, updateTask)
+            }
+
+            $scope.discover = function () {
+
+                $scope.discovery.pending = true;
+                $scope.projectsTable.selectAll(false);
+
+                JenkinsRequest.list({job_id: $scope.job.id, filter: $scope.discovery.pattern}, registerTask)
+            };
+
+            $scope.addProjects = function () {
+                var data,
+                    success,
+                    error,
+                    deferred = $q.defer(),
+                    project_names = _.map($scope.projectsTable.getSelected(), function (item) {
+                        return item.name;
+                    });
+
+                    data = {
+                        'projects': project_names
+                    };
+
+                success = function (response) {
+                    $scope.successMessages.push(translate('Added %x projects to job %y.')
+                        .replace('%x', $scope.projectsTable.numSelected)
+                        .replace('%y', $scope.job.name));
+                    $scope.projectsTable.working = false;
+                    $scope.projectsTable.rows = _.difference($scope.projectsTable.rows, $scope.projectsTable.getSelected())
+                    $scope.projectsTable.selectAll(false);
+                    deferred.resolve(response);
+                };
+
+                error = function (response) {
+                    deferred.reject(response.data.errors);
+                    angular.forEach(response.data.errors, function (errorMessage, key) {
+                            if (angular.isString(key)) {
+                                errorMessage = [key, errorMessage].join(' ');
+                            }
+                            $scope.errorMessages.push(translate('Error occured while saving Adding Projects: ') + errorMessage);
+                        });
+                    $scope.projectsTable.working = false;
+                };
+
+                $scope.projectsTable.working = true;
+                Job.addProjects({id: $scope.job.id}, data, success, error);
+                return deferred.promise;
+            };
+
+
+        }
+]);

data/app/assets/javascripts/foreman_pipeline/jobs/details/project-discovery/job-projects-parameters.controller.js

@@ -0,0 +1,54 @@
+angular.module('ForemanPipeline.jobs').controller('JobProjectsParametersController', 
+    ['$scope', '$state', '$q', 'translate', 'JenkinsProjectParam', 'JenkinsProject',
+        function ($scope, $state, $q, translate, JenkinsProjectParam, JenkinsProject) {
+
+            $scope.successMessages = [];
+            $scope.errorMessages = [];
+            $scope.projectParamsList = [];
+            var loadParameters;
+
+            $scope.loading = true;
+
+            loadParameters = function () {                 
+                $scope.projectParamsList = _.map($scope.jenkinsProject.jenkins_project_params, function (item) {
+                    if(item.type === "boolean") {
+                        if(item.value === "t" || item.value === "true") {
+                            item.value = true;
+                        } else {
+                            item.value = false;
+                        }
+                    }
+                    return item
+                });
+                $scope.loading = false;
+            };
+
+            $scope.jenkinsProject = JenkinsProject.get({
+                'id': $scope.$stateParams.projectId
+            }, loadParameters);
+
+            $scope.save = function (param, index) {
+                var success, error,
+                    deferred = $q.defer();
+
+                success = function (response) {
+                    deferred.resolve(response);
+                    $scope.successMessages.push(translate("Parameter %x successfully updated").replace("%x", param.name));
+
+                };
+
+                error = function (response) {
+                    deferred.reject(response);
+                    angular.forEach(response.data.errors, function (errorMessage, key) {
+                            if (angular.isString(key)) {
+                                errorMessage = [key, errorMessage].join(' ');
+                            }
+                            $scope.errorMessages.push(translate('Error occured while saving Project Param: ') + errorMessage);
+                        });
+                };
+                JenkinsProjectParam.update({id: param.id}, param, success, error);
+                return deferred.promise;
+            };
+            
+    }
+]);