quay/static/js/directives/ui/add-repo-permissions.js

/**
 * An element which displays a table for adding permissions for an entity to repositories under
 * a namespace.
 */
angular.module('quay').directive('addRepoPermissions', function () {
  var directiveDefinitionObject = {
    priority: 0,
    templateUrl: '/static/directives/add-repo-permissions.html',
    replace: false,
    transclude: true,
    restrict: 'C',
    scope: {
      'namespace': '=namespace',
      'entityName': '=entityName',
      'entityKind': '=entityKind',

      'checkedRepository': '=checkedRepository',

      'addPermissions': '=addPermissions',

      'hasCheckedRepositories': '=hasCheckedRepositories',

      'repositoriesLoaded': '&repositoriesLoaded',
      'addingPermissions': '&addingPermissions',
      'permissionsAdded': '&permissionsAdded',
    },

    controller: function($scope, $element, ApiService, UIService, TableService, RolesService) {
      $scope.TableService = TableService;

      $scope.options = {
        'predicate': 'last_modified_datetime',
        'reverse': false,
        'filter': ''
      };

      $scope.repositories = null;
      $scope.currentNamespace = null;

      var handleRepoCheckChange = function() {
        $scope.repositories.forEach(function(repo) {
          if ($scope.checkedRepos.isChecked(repo)) {
            if (repo['permission'] == 'none') {
              repo['permission'] = 'read';
            }
          } else {
            repo['permission'] = 'none';
          }
        });

        $scope.hasCheckedRepositories = !!$scope.checkedRepos.checked.length;
      };

      var setRepoState = function() {
        if (!$scope.repositories) {
          return;
        }

        $scope.orderedRepositories = TableService.buildOrderedItems(
            $scope.repositories, $scope.options,
            ['name', 'permission'],
            ['last_modified_datetime']);
      };

      var loadRepositories = function() {
        if (!$scope.namespace || !$scope.entityName || !$scope.entityKind) {
          return;
        }

        if ($scope.namespace == $scope.currentNamespace) {
          return;
        }

        // Load the repositories under the entity's namespace.
        var params = {
          'namespace': $scope.namespace,
          'last_modified': true
        };

        ApiService.listRepos(null, params).then(function(resp) {
          $scope.currentNamespace = $scope.namespace;

          var repos = [];
          resp['repositories'].forEach(function(repo) {
            repos.push({
              'namespace': repo.namespace,
              'name': repo.name,
              'last_modified': repo.last_modified,
              'last_modified_datetime': TableService.getReversedTimestamp(repo.last_modified),
              'permission': 'none'
            });
          });

          if (repos.length == 0) {
            $scope.repositoriesLoaded({'repositories': repos});
            return;
          }

          $scope.repositories = repos;
          $scope.checkedRepos = UIService.createCheckStateController($scope.repositories, 'name');
          $scope.checkedRepos.listen(handleRepoCheckChange);

          if ($scope.checkedRepository) {
            repos.forEach(function(repo) {
              if (repo['namespace'] == $scope.checkedRepository.namespace &&
                  repo['name'] == $scope.checkedRepository.name) {
                $scope.checkedRepos.checkItem(repo);
                $scope.options.filter = $scope.checkedRepository.name;
              }
            });
          }

          setRepoState();
          $scope.repositoriesLoaded({'repositories': repos});
        }, ApiService.errorDisplay('Could not load repositories'));
      };

      var addPermissions = function() {
        if (!$scope.checkedRepos || !$scope.namespace || !$scope.repositories) {
          return;
        }

        $scope.addingPermissions();

        var repos = $scope.checkedRepos.checked;
        var counter = 0;

        var addPerm = function() {
          if (counter >= repos.length) {
            $scope.permissionsAdded();
            return;
          }

          var repo = repos[counter];
          RolesService.setRepositoryRole(repo, repo.permission, $scope.entityKind,
                                         $scope.entityName,
            function(status) {
              if (status) {
                counter++;
                addPerm();
              } else {
                $scope.permissionsAdded();
              }
            });
        };

        addPerm();
      };

      $scope.setRole = function(role, repo) {
        repo['permission'] = role;

        if (role == 'none') {
          $scope.checkedRepos.uncheckItem(repo);
        } else {
          $scope.checkedRepos.checkItem(repo);
        }
      };

      $scope.allRepositoriesFilter = function(item) {
        return true;
      };

      $scope.noRepositoriesFilter = function(item) {
        return false;
      };

      $scope.missingPermsRepositoriesFilter = function(item) {
        return !item.perm;
      };

      $scope.$watch('options.predicate', setRepoState);
      $scope.$watch('options.reverse', setRepoState);
      $scope.$watch('options.filter', setRepoState);

      $scope.$watch('namespace', loadRepositories);
      $scope.$watch('entityName', loadRepositories);
      $scope.$watch('entityKind', loadRepositories);

      $scope.$watch('addPermissions', function(value) {
        if (value) {
          addPermissions();
        }
      });
    }
  };
  return directiveDefinitionObject;
});