quay/static/js/controllers.js

$.fn.clipboardCopy = function() { 
  var clip = new ZeroClipboard($(this),  { 'moviePath': 'static/lib/ZeroClipboard.swf' });  

  clip.on('complete', function() {
    // Resets the animation.
    var elem = $('#clipboardCopied')[0];
    elem.style.display = 'none';
    elem.classList.remove('animated');

    // Show the notification.
    setTimeout(function() {
      elem.style.display = 'inline-block';
      elem.classList.add('animated');
    }, 10);
  });
};

function GuideCtrl() {
}

function SecurityCtrl($scope) {
}

function ContactCtrl($scope) {
}

function PlansCtrl($scope, $location, UserService, PlanService) {
  // Load the list of plans.
  PlanService.getPlans(function(plans) {
    $scope.plans = plans;
  }, /* include the personal plan */ true);

  // Monitor any user changes and place the current user into the scope.
  UserService.updateUserIn($scope);

  $scope.signedIn = function() {
    $('#signinModal').modal('hide');
    PlanService.handleNotedPlan();    
  };
    
  $scope.buyNow = function(plan) {
    PlanService.notePlan(plan);
    if ($scope.user && !$scope.user.anonymous) {
      PlanService.handleNotedPlan();    
    } else {
      $('#signinModal').modal({});
    }
  };
}

function TutorialCtrl($scope, AngularTour, AngularTourSignals, UserService) {
  // Default to showing sudo on all commands if on linux.
  var showSudo = navigator.appVersion.indexOf("Linux") != -1;

  $scope.tour = {
    'title': 'Quay.io Tutorial',
    'initialScope': {
      'showSudo': showSudo
    },
    'steps': [
      {
        'title': 'Welcome to the Quay.io tutorial!',
        'templateUrl': '/static/tutorial/welcome.html'        
      },
      {
        'title': 'Sign in to get started',
        'templateUrl': '/static/tutorial/signup.html',
        'signal': function($tourScope) {
          var user = UserService.currentUser();
          $tourScope.username = user.username;
          $tourScope.email = user.email;
          $tourScope.inOrganization = user.organizations && user.organizations.length > 0;
          return !user.anonymous;
        }
      },
      {
        'title': 'Step 1: Login to Quay.io',
        'templateUrl': '/static/tutorial/docker-login.html',
        'signal': AngularTourSignals.serverEvent('/realtime/user/subscribe?events=docker-cli',
                                                 function(message) {
                                                   return message['data']['action'] == 'login';
                                                 }),
        'waitMessage': "Waiting for docker login",
        'skipTitle': "I'm already logged in",
        'mixpanelEvent': 'tutorial_start'
      },
      {
        'title': 'Step 2: Create a new container',
        'templateUrl': '/static/tutorial/create-container.html'
      },
      {
        'title': 'Step 3: Create a new image',
        'templateUrl': '/static/tutorial/create-image.html'
      },
      {
        'title': 'Step 4: Push the image to Quay.io',
        'templateUrl': '/static/tutorial/push-image.html',
        'signal': AngularTourSignals.serverEvent('/realtime/user/subscribe?events=docker-cli',
                                                 function(message, tourScope) {
                                                   var pushing = message['data']['action'] == 'push_repo';
                                                   if (pushing) {
                                                     tourScope.repoName = message['data']['repository'];
                                                   }
                                                   return pushing;
                                                 }),
        'waitMessage': "Waiting for repository push to begin",
        'mixpanelEvent': 'tutorial_wait_for_push'
      },
      {
        'title': 'Push in progress',
        'templateUrl': '/static/tutorial/pushing.html',
        'signal': AngularTourSignals.serverEvent('/realtime/user/subscribe?events=docker-cli',
                                                 function(message, tourScope) {
                                                   return message['data']['action'] == 'pushed_repo';
                                                 }),
        'waitMessage': "Waiting for repository push to complete"
      },
      {
        'title': 'Step 5: View the repository on Quay.io',
        'templateUrl': '/static/tutorial/view-repo.html',
        'signal': AngularTourSignals.matchesLocation('/repository/'),
        'overlayable': true,
        'mixpanelEvent': 'tutorial_push_complete'
      },
      {
        'templateUrl': '/static/tutorial/view-repo.html',
        'signal': AngularTourSignals.matchesLocation('/repository/'),
        'overlayable': true
      },
      {
        'templateUrl': '/static/tutorial/waiting-repo-list.html',
        'signal': AngularTourSignals.elementAvaliable('*[data-repo="{{username}}/{{repoName}}"]'),
        'overlayable': true
      },
      {
        'templateUrl': '/static/tutorial/repo-list.html',
        'signal': AngularTourSignals.matchesLocation('/repository/{{username}}/{{repoName}}'),
        'element': '*[data-repo="{{username}}/{{repoName}}"]',
        'overlayable': true
      },
      {
        'title': 'Repository View',
        'content': 'This is the repository view page. It displays all the primary information about your repository.',
        'overlayable': true,
        'mixpanelEvent': 'tutorial_view_repo'
      },
      {
        'title': 'Image History',
        'content': 'The tree displays the full history of your repository, including all its tag. ' +
          'You can click on a tag or image to see its information.',
        'element': '#image-history-container',
        'overlayable': true
      },
      {
        'title': 'Tag/Image Information',
        'content': 'This panel displays information about the currently selected tag or image',
        'element': '#side-panel',
        'overlayable': true
      },
      {
        'title': 'Select tag or image',
        'content': 'You can select a tag or image by clicking on this dropdown',
        'element': '#side-panel-dropdown',
        'overlayable': true
      },
      {
        'content': 'To view the admin settings for the repository, click on the gear',
        'element': '#admin-cog',
        'signal': AngularTourSignals.matchesLocation('/repository/{{username}}/{{repoName}}/admin'),
        'overlayable': true
      },
      {
        'title': 'Repository Admin',
        'content': "The repository admin panel allows for modification of a repository's permissions, webhooks, visibility and other settings",
        'overlayable': true,
        'mixpanelEvent': 'tutorial_view_admin'
      },
      {
        'title': 'Permissions',
        'templateUrl': '/static/tutorial/permissions.html',
        'overlayable': true,
        'element': '#permissions'
      },
      {
        'title': 'Adding a permission',
        'content': 'To add an <b>additional</b> permission, enter a username or robot account name into the autocomplete ' +
          'or hit the dropdown arrow to manage robot accounts',
        'overlayable': true,
        'element': '#add-entity-permission'
      },
      {
        'templateUrl': '/static/tutorial/done.html',
        'overlayable': true,
        'mixpanelEvent': 'tutorial_complete'
      }
    ]
  };
}

function RepoListCtrl($scope, $sanitize, Restangular, UserService, ApiService) {
  $scope.namespace = null;
  $scope.page = 1;
  $scope.publicPageCount = null;
 
  // Monitor changes in the user.
  UserService.updateUserIn($scope, function() {
    loadMyRepos($scope.namespace);
  });

  // Monitor changes in the namespace.
  $scope.$watch('namespace', function(namespace) {
    loadMyRepos(namespace);
  });

  $scope.movePublicPage = function(increment) {
    if ($scope.publicPageCount == null) {
      return;
    }

    $scope.page += increment;
    if ($scope.page < 1) {
      $scope.page = 1;
    }

    if ($scope.page > $scope.publicPageCount) {
      $scope.page = $scope.publicPageCount;
    }

    loadPublicRepos();
  };

  var loadMyRepos = function(namespace) {
    if (!$scope.user || $scope.user.anonymous || !namespace) {
      return;
    }

    var options = {'public': false, 'sort': true, 'namespace': namespace};
    
    $scope.user_repositories = ApiService.listReposAsResource().withOptions(options).get(function(resp) {
      return resp.repositories;
    });
  };

  var loadPublicRepos = function() {
    var options = {
      'public': true,
      'private': false,
      'sort': true,
      'limit': 10,
      'page': $scope.page,
      'count': $scope.page == 1
    };

    $scope.public_repositories = ApiService.listReposAsResource().withOptions(options).get(function(resp) {
      if (resp.count) {
        $scope.publicPageCount = Math.ceil(resp.count / 10);
      }
      return resp.repositories;
    });
  };

  loadPublicRepos();
}

function LandingCtrl($scope, UserService, ApiService) {
  $scope.namespace = null;

  $scope.$watch('namespace', function(namespace) {
    loadMyRepos(namespace);
  });

  UserService.updateUserIn($scope, function() {
    loadMyRepos($scope.namespace);
  });

  $scope.canCreateRepo = function(namespace) {
    if (!$scope.user) { return false; }

    if (namespace == $scope.user.username) {
      return true;
    }
    
    if ($scope.user.organizations) {
      for (var i = 0; i < $scope.user.organizations.length; ++i) {
        var org = $scope.user.organizations[i];
        if (org.name == namespace) {
          return org.can_create_repo;
        }
      }
    }

    return false;
  };

  var loadMyRepos = function(namespace) {
    if (!$scope.user || $scope.user.anonymous || !namespace) {
      return;
    }

    var options = {'limit': 4, 'public': false, 'sort': true, 'namespace': namespace };
    $scope.my_repositories = ApiService.listReposAsResource().withOptions(options).get(function(resp) {
      return resp.repositories;
    });
  };

  browserchrome.update();
}

function RepoCtrl($scope, $sanitize, Restangular, ImageMetadataService, ApiService, $routeParams, $rootScope, $location, $timeout) {
  var namespace = $routeParams.namespace;
  var name = $routeParams.name;

  $rootScope.title = 'Loading...';

  // Watch for the destruction of the scope.
  $scope.$on('$destroy', function() {
    if ($scope.tree) {
      $scope.tree.dispose();
    }
  });

  // Watch for changes to the repository.
  $scope.$watch('repo', function() {
    if ($scope.tree) {
      $timeout(function() {
        $scope.tree.notifyResized();
      });
    }
  });

  // Watch for changes to the tag parameter.
  $scope.$on('$routeUpdate', function(){
    if ($location.search().tag) {
      $scope.setTag($location.search().tag, false);
    } else if ($location.search().image) {
      $scope.setImage($location.search().image, false);
    } else {
      $scope.setTag($location.search().tag, false);
    }
  });

  // Start scope methods //////////////////////////////////////////

  $scope.buildDialogShowCounter = 0;
  $scope.getFormattedCommand = ImageMetadataService.getFormattedCommand;

  $scope.showNewBuildDialog = function() {
    $scope.buildDialogShowCounter++;
  };

  $scope.handleBuildStarted = function(build) {
    startBuildInfoTimer($scope.repo);
  };

  $scope.showBuild = function(buildInfo) {
    $location.path('/repository/' + namespace + '/' + name + '/build');
    $location.search('current', buildInfo.id);
  };

  $scope.getTooltipCommand = function(image) {
    var sanitized = ImageMetadataService.getEscapedFormattedCommand(image);
    return '<span class=\'codetooltip\'>' + sanitized + '</span>';
  };

  $scope.updateForDescription = function(content) {
    $scope.repo.description = content;
    $scope.repo.put();
  };

  $scope.parseDate = function(dateString) {
    return Date.parse(dateString);
  };

  $scope.getTimeSince = function(createdTime) {
      return moment($scope.parseDate(createdTime)).fromNow();
  };

  $scope.loadImageChanges = function(image) {
    var params = {'repository': namespace + '/' + name, 'image_id': image.id};
    $scope.currentImageChangeResource = ApiService.getImageChangesAsResource(params).get(function(ci) {
      $scope.currentImageChanges = ci;
    });
  };

  $scope.getMoreCount = function(changes) {
    if (!changes) { return 0; }
    var addedDisplayed = Math.min(5, changes.added.length);
    var removedDisplayed = Math.min(5, changes.removed.length);
    var changedDisplayed = Math.min(5, changes.changed.length);

    return (changes.added.length + changes.removed.length + changes.changed.length) -
      addedDisplayed - removedDisplayed - changedDisplayed;
  };

  $scope.setImage = function(imageId, opt_updateURL) {
    var image = null;
    for (var i = 0; i < $scope.images.length; ++i) {
      var currentImage = $scope.images[i];
      if (currentImage.id == imageId || currentImage.id.substr(0, 12) == imageId) {
        image = currentImage;
        break;
      }
    }

    if (!image) { return; }

    $scope.currentTag = null;
    $scope.currentImage = image;
    $scope.loadImageChanges(image);
    if ($scope.tree) {
      $scope.tree.setImage(image.id);
    }

    if (opt_updateURL) {
      $location.search('tag', null);
      $location.search('image', imageId.substr(0, 12));
    }
  };

  $scope.tagSpecificImages = function(tagName) {
    if (!tagName) { return []; }

    var tag = $scope.repo.tags[tagName];
    if (!tag) { return []; }

    if ($scope.specificImages && $scope.specificImages[tagName]) {
      return $scope.specificImages[tagName];
    }

    var getIdsForTag = function(currentTag) {
      var ids = {};
      forAllTagImages(currentTag, function(image) {
        ids[image.dbid] = true;
      });
      return ids;
    };

    // Remove any IDs that match other tags.
    var toDelete = getIdsForTag(tag);
    for (var currentTagName in $scope.repo.tags) {
      var currentTag = $scope.repo.tags[currentTagName];
      if (currentTag != tag) {
        for (var dbid in getIdsForTag(currentTag)) {
          delete toDelete[dbid];
        }
      }
    }

    // Return the matching list of images.
    var images = [];
    for (var i = 0; i < $scope.images.length; ++i) {
      var image = $scope.images[i];
      if (toDelete[image.dbid]) {
        images.push(image);
      }
    }
      
    images.sort(function(a, b) {
      var result = new Date(b.created) - new Date(a.created);
      if (result != 0) {
        return result;
      }

      return b.dbid - a.dbid;
    });

    $scope.specificImages[tagName] = images;
    return images;
  };

  $scope.askDeleteTag = function(tagName) {
    if (!$scope.repo.can_admin) { return; }

    $scope.tagToDelete = tagName;
    $('#confirmdeleteTagModal').modal('show');
  };

  $scope.deleteTag = function(tagName) {
    if (!$scope.repo.can_admin) { return; }
    $('#confirmdeleteTagModal').modal('hide');

    var params = {
      'repository': namespace + '/' + name,
      'tag': tagName
    };

    ApiService.deleteFullTag(null, params).then(function() {
      loadViewInfo();
    }, function(resp) {
      bootbox.dialog({
        "message": resp.data ? resp.data : 'Could not delete tag',
        "title": "Cannot delete tag",
        "buttons": {
          "close": {
            "label": "Close",
            "className": "btn-primary"
          }
        }
      });
    });
  };

  $scope.getImagesForTagBySize = function(tag) {
    var images = [];
    forAllTagImages(tag, function(image) {
        images.push(image);
    });

    images.sort(function(a, b) {
      return b.size - a.size;
    });

    return images;
  };

  $scope.getTotalSize = function(tag) {
    var size = 0;
    forAllTagImages(tag, function(image) {
      size += image.size;
    });
    return size;
  };

  $scope.setTag = function(tagName, opt_updateURL) {
    var repo = $scope.repo;
    var proposedTag = repo.tags[tagName];
    if (!proposedTag) {
      // We must find a good default
      for (tagName in repo.tags) {
        if (!proposedTag || tagName == 'latest') {
          proposedTag = repo.tags[tagName];          
        }
      }
    }

    if (proposedTag) {
      $scope.currentTag = proposedTag;
      $scope.currentImage = $scope.currentTag.image;
      $scope.loadImageChanges($scope.currentImage);
      if ($scope.tree) {
        $scope.tree.setTag($scope.currentTag.name);
      } 

      if (opt_updateURL) {
        $location.search('image', null);
        $location.search('tag', $scope.currentTag.name);
      }
    }

    if ($scope.currentTag && !repo.tags[$scope.currentTag.name]) {
      $scope.currentTag = null;
      $scope.currentImage = null;
    }
  };

  $scope.getFirstTextLine = getFirstTextLine;

  $scope.getImageListingClasses = function(image, tagName) {
    var classes = '';
    if (image.ancestors.length > 1) {
      classes += 'child ';
    }
 
    var currentTag = $scope.repo.tags[tagName];
    if (image.dbid == currentTag.image.dbid) {
      classes += 'tag-image ';
    }

    return classes;
  };

  $scope.getTagCount = function(repo) {
    if (!repo) { return 0; }
    var count = 0;
    for (var tag in repo.tags) {
      ++count;
    }
    return count;
  };

  $scope.hideTagMenu = function(tagName, clientX, clientY) {
    $scope.currentMenuTag = null;

    var tagMenu = $("#tagContextMenu");
    tagMenu.hide();
  };

  $scope.showTagMenu = function(tagName, clientX, clientY) {
    if (!$scope.repo.can_admin) { return; }

    $scope.currentMenuTag = tagName;

    var tagMenu = $("#tagContextMenu");
    tagMenu.css({
      display: "block",
      left: clientX,
      top: clientY
    });

    tagMenu.on("blur", function() {
      setTimeout(function() {
        tagMenu.hide();
      }, 100); // Needed to allow clicking on menu items.
    });

    tagMenu.on("click", "a", function() {
      setTimeout(function() {
        tagMenu.hide();
      }, 100); // Needed to allow clicking on menu items.
    });

    tagMenu[0].focus();
  };

  var getDefaultTag = function() {
    if ($scope.repo === undefined) {
      return undefined;
    } else if ($scope.repo.tags.hasOwnProperty('latest')) {
      return $scope.repo.tags['latest'];
    } else {
      for (key in $scope.repo.tags) {
        return $scope.repo.tags[key];
      }
    }
  };

  var forAllTagImages = function(tag, callback) {
    if (!tag || !$scope.imageByDBID) { return; }

    callback(tag.image);

    var ancestors = tag.image.ancestors.split('/');
    for (var i = 0; i < ancestors.length; ++i) {
      var image = $scope.imageByDBID[ancestors[i]];
      if (image) {
        callback(image);
      }
    }
  };

  var fetchRepository = function() {
    var params = {'repository': namespace + '/' + name};
    $rootScope.title = 'Loading Repository...';
    $scope.repository = ApiService.getRepoAsResource(params).get(function(repo) {
      // Set the repository object.
      $scope.repo = repo;

      // Set the default tag.
      $scope.setTag($routeParams.tag);

      // Set the title of the page.
      var qualifiedRepoName = namespace + '/' + name;
      $rootScope.title = qualifiedRepoName;
      var kind = repo.is_public ? 'public' : 'private';
      $rootScope.description = jQuery(getFirstTextLine(repo.description)).text() ||
        'Visualization of images and tags for ' + kind + ' Docker repository: ' + qualifiedRepoName;

      // If the repository is marked as building, start monitoring it for changes.
      if (repo.is_building) {
        startBuildInfoTimer(repo);
      }

      $('#copyClipboard').clipboardCopy();
    });
  };

  var startBuildInfoTimer = function(repo) {
    if ($scope.interval) { return; }

    getBuildInfo(repo);
    $scope.interval = setInterval(function() {
      $scope.$apply(function() { getBuildInfo(repo); });
    }, 5000);

    $scope.$on("$destroy", function() {
      cancelBuildInfoTimer();
    });
  };

  var cancelBuildInfoTimer = function() {
    if ($scope.interval) {
      clearInterval($scope.interval);
    }
  };

  var getBuildInfo = function(repo) {
    var params = {
      'repository': repo.namespace + '/' + repo.name
    };

    ApiService.getRepoBuilds(null, params, true).then(function(resp) {
      var runningBuilds = [];
      for (var i = 0; i < resp.builds.length; ++i) {
        var build = resp.builds[i];
        if (build.status != 'complete') {
          runningBuilds.push(build);
        }
      }

      $scope.buildsInfo = runningBuilds;
      if (!runningBuilds.length) {
        // Cancel the build timer.
        cancelBuildInfoTimer();

        // Mark the repo as no longer building.
        $scope.repo.is_building = false;

        // Reload the repo information.
        loadViewInfo();
      }
    });
  };

  var listImages = function() {
    var params = {'repository': namespace + '/' + name};    
    $scope.imageHistory = ApiService.listRepositoryImagesAsResource(params).get(function(resp) {
      $scope.images = resp.images;
      $scope.specificImages = [];

      // Build various images for quick lookup of images.
      $scope.imageByDBID = {};
      for (var i = 0; i < $scope.images.length; ++i) {
        var currentImage = $scope.images[i];
        $scope.imageByDBID[currentImage.dbid] = currentImage;
      }

      // Dispose of any existing tree.
      if ($scope.tree) {
        $scope.tree.dispose();
      }

      // Create the new tree.
      $scope.tree = new ImageHistoryTree(namespace, name, resp.images,
          getFirstTextLine, $scope.getTimeSince, ImageMetadataService.getEscapedFormattedCommand);

      $scope.tree.draw('image-history-container');

      // If we already have a tag, use it
      if ($scope.currentTag) {
        $scope.tree.setTag($scope.currentTag.name);
      }

      // Listen for changes to the selected tag and image in the tree.
      $($scope.tree).bind('tagChanged', function(e) {
        $scope.$apply(function() { $scope.setTag(e.tag, true); });
      });

      $($scope.tree).bind('imageChanged', function(e) {
        $scope.$apply(function() { $scope.setImage(e.image.id, true); });
      });

      $($scope.tree).bind('showTagMenu', function(e) {
        $scope.$apply(function() { $scope.showTagMenu(e.tag, e.clientX, e.clientY); });
      });

      $($scope.tree).bind('hideTagMenu', function(e) {
        $scope.$apply(function() { $scope.hideTagMenu(); });
      });

      if ($routeParams.image) {
        $scope.setImage($routeParams.image);
      }

      return resp.images;
    });
  };

  var loadViewInfo = function() {
    fetchRepository();
    listImages();
  };

  // Fetch the repository itself as well as the image history.
  loadViewInfo();
}

function BuildPackageCtrl($scope, Restangular, ApiService, $routeParams, $rootScope, $location, $timeout) {
  var namespace = $routeParams.namespace;
  var name = $routeParams.name;
  var buildid = $routeParams.buildid;

  var params = {
    'repository': namespace + '/' + name,
    'build_uuid': buildid
  };

  $scope.initializeTree = function() {
    if ($scope.drawn) {
      $scope.tree.notifyResized();
      return;
    }

    $scope.drawn = true;
    $timeout(function() {
      $scope.tree.draw('file-tree-container');
    }, 10);
  };

  $scope.downloadForUser = function() {
    var blob = $scope.zip.generate({type:"blob"});
    saveAs(blob, $scope.repobuild['display_name'] + '.zip');
  };

  var processBuildPack = function(response) {
    // Try to load as a zip file.
    var zipFiles = null;
    var zip = null;
    try {      
      var zip = new JSZip(response);
      zipFiles = zip.files;
    } catch (e) {
    }
    
    // Find the Dockerfile in the zip file. If there isn't any zip file, then the response
    // itself (should) be the Dockerfile.
    if (zipFiles && Object.keys(zipFiles).length) {
      // Load the dockerfile contents.
      var dockerfile = zip.file('Dockerfile');
      if (dockerfile) {
        $scope.dockerFileContents = dockerfile.asText();
      }

      // Build the zip file tree.
      $scope.zip = zip;
      $scope.tree = new FileTree(Object.keys(zipFiles));
      $($scope.tree).bind('fileClicked', function(e) {
        var file = zip.file(e.path);
        if (file) {
          var blob = new Blob([file.asArrayBuffer()]);
          saveAs(blob, file.name);
        }
      });      
    } else {
      $scope.dockerFileContents = response;
    }

    $scope.loaded = true;
  };
  
  var downloadBuildPack = function() {
    $scope.downloadProgress = 0;
    $scope.downloading = true;

    ApiService.getRepoBuildArchiveUrl(null, params).then(function(resp) {
      startDownload(resp['url']);
    }, function() {
      $scope.downloading = false;
      $scope.downloadError = true;
    });
  };

  var startDownload = function(url) {
    var request = new XMLHttpRequest();
    request.open('GET', url, true);
    if (request.overrideMimeType) {
      request.overrideMimeType('text/plain; charset=x-user-defined');
    }
    request.onprogress = function(e) {
      $scope.$apply(function() {
        var percentLoaded;
        if (e.lengthComputable) {
          $scope.downloadProgress = (e.loaded / e.total) * 100;
        }
      });
    };
    request.onerror = function() {
      $scope.$apply(function() {
        $scope.downloading = false;
        $scope.downloadError = true;
      });
    };
    request.onreadystatechange = function() {
      var state = request.readyState;
      if (state == 4) {
        $scope.$apply(function() {
          $scope.downloading = false;
          processBuildPack(request.responseText);
        });
        return;
      }
    };
    request.send();
  };

  var getBuildInfo = function() {
    $scope.repository_build = ApiService.getRepoBuildStatus(null, params, true).then(function(resp) {
      if (!resp['is_writer']) {
        $rootScope.title = 'Unknown build';
        $scope.accessDenied = true;
        return;
      }
      
      $rootScope.title = 'Repository Build Pack - ' + resp['display_name'];
      $scope.repobuild = resp;
      $scope.repo = {
        'namespace': namespace,
        'name': name
      };

      downloadBuildPack();
      return resp;
    });
  };

  getBuildInfo();
}

function RepoBuildCtrl($scope, Restangular, ApiService, $routeParams, $rootScope, $location, $interval, $sanitize, ansi2html) {
  var namespace = $routeParams.namespace;
  var name = $routeParams.name;
  var pollTimerHandle = null;

  $scope.$on('$destroy', function() {
    stopPollTimer();
  });

  // Watch for changes to the current parameter.
  $scope.$on('$routeUpdate', function(){
    if ($location.search().current) {
      $scope.setCurrentBuild($location.search().current, false);
    }
  });

  $scope.builds = [];
  $scope.polling = false;

  $scope.buildDialogShowCounter = 0;

  $scope.showNewBuildDialog = function() {
    $scope.buildDialogShowCounter++;
  };

  $scope.handleBuildStarted = function(newBuild) {
    $scope.builds.push(newBuild);
    $scope.setCurrentBuild(newBuild['id'], true);
  };

  $scope.adjustLogHeight = function() {
    var triggerOffset = 0;
    if ($scope.currentBuild && $scope.currentBuild.trigger) {
      triggerOffset = 85;
    }
    $('.build-logs').height($(window).height() - 415 - triggerOffset);
  };

  $scope.askRestartBuild = function(build) {
    $('#confirmRestartBuildModal').modal({});
  };

  $scope.restartBuild = function(build) {
    $('#confirmRestartBuildModal').modal('hide');

    var data = {
      'file_id': build['resource_key']
    };

    var params = {
      'repository': namespace + '/' + name
    };

    ApiService.requestRepoBuild(data, params).then(function(newBuild) {
      $scope.builds.push(newBuild);
      $scope.setCurrentBuild(newBuild['id'], true);
    });
  };

  $scope.hasLogs = function(container) {
    return ((container.logs && container.logs.length) || (container._logs && container._logs.length));
  };

  $scope.toggleLogs = function(container) {
    if (container._logs) {
      container.logs = container._logs;
      container._logs = null;
    } else {
      container._logs = container.logs;
      container.logs = null;
    }
  };  

  $scope.setCurrentBuild = function(buildId, opt_updateURL) {
    // Find the build.
    for (var i = 0; i < $scope.builds.length; ++i) {
      if ($scope.builds[i].id == buildId) {
        $scope.setCurrentBuildInternal(i, $scope.builds[i], opt_updateURL);
        return;
      }
    }
  };

  $scope.processANSI = function(message, container) {
    var filter = container.logs._filter = (container.logs._filter || ansi2html.create());
    
    // Note: order is important here.
    var setup = filter.getSetupHtml();
    var stream = filter.addInputToStream(message);
    var teardown = filter.getTeardownHtml();
    return setup + stream + teardown;
  };

  $scope.setCurrentBuildInternal = function(index, build, opt_updateURL) {
    if (build == $scope.currentBuild) { return; }

    stopPollTimer();

    $scope.logEntries = null;
    $scope.logStartIndex = null;
    $scope.currentParentEntry = null;

    $scope.currentBuild = build;
    $scope.currentBuildIndex = index;

    if (opt_updateURL) {
      if (build) {
        $location.search('current', build.id);
      } else {
        $location.search('current', null);
      }
    }

    // Timeout needed to ensure the log element has been created
    // before its height is adjusted.
    setTimeout(function() {
      $scope.adjustLogHeight();
    }, 1);

    // Load the first set of logs.
    getBuildStatusAndLogs();

    // If the build is currently processing, start the build timer.
    checkPollTimer();
  };

  var checkPollTimer = function() {
    var build = $scope.currentBuild;
    if (!build) {
      stopPollTimer();
      return;
    }

    if (build['phase'] != 'complete' && build['phase'] != 'error') {
      startPollTimer();
      return true;
    } else {
      stopPollTimer();
      return false;
    }
  };

  var stopPollTimer = function() {    
    $interval.cancel(pollTimerHandle);
  };

  var startPollTimer = function() {
    stopPollTimer();
    pollTimerHandle = $interval(getBuildStatusAndLogs, 2000);
  };

  var processLogs = function(logs, startIndex) {
    if (!$scope.logEntries) { $scope.logEntries = []; }

    for (var i = 0; i < logs.length; ++i) {
      var entry = logs[i];
      var type = entry['type'] || 'entry';
      if (type == 'command' || type == 'phase' || type == 'error') {
        entry['_logs'] = [];
        entry['index'] = startIndex + i;

        $scope.logEntries.push(entry);
        $scope.currentParentEntry = entry;      
      } else if ($scope.currentParentEntry) {
        if ($scope.currentParentEntry['logs']) {
          $scope.currentParentEntry['logs'].push(entry);
        } else {
          $scope.currentParentEntry['_logs'].push(entry);
        }
      }
    }
  };

  var getBuildStatusAndLogs = function() {
    if (!$scope.currentBuild || $scope.polling) { return; }
    $scope.polling = true;
    
    var params = {
      'repository': namespace + '/' + name,
      'build_uuid': $scope.currentBuild.id
    };

    ApiService.getRepoBuildStatus(null, params, true).then(function(resp) {
      // Note: We use extend here rather than replacing as Angular is depending on the
      // root build object to remain the same object.
      $.extend(true, $scope.builds[$scope.currentBuildIndex], resp);
      checkPollTimer();

      // Load the updated logs for the build.
      var options = {
        'start': $scope.logStartIndex
      };

      ApiService.getRepoBuildLogsAsResource(params, true).withOptions(options).get(function(resp) {       
        if ($scope.logStartIndex != null && resp['start'] != $scope.logStartIndex) {
          $scope.polling = false;
          return;
        }
        
        processLogs(resp['logs'], resp['start']);
        $scope.logStartIndex = resp['total'];
        $scope.polling = false;
      }, function() {
        $scope.polling = false;
      });
    });
  };

  var fetchRepository = function() {
    var params = {'repository': namespace + '/' + name};
    $rootScope.title = 'Loading Repository...';
    $scope.repository = ApiService.getRepoAsResource(params).get(function(repo) {
      if (!repo.can_write) {
        $rootScope.title = 'Unknown builds';
        $scope.accessDenied = true;
        return;
      }

      $rootScope.title = 'Repository Builds';
      $scope.repo = repo;

      getBuildInfo();
    });
  };

  var getBuildInfo = function(repo) {
    var params = {
      'repository': namespace + '/' + name
    };

    ApiService.getRepoBuilds(null, params).then(function(resp) {
      $scope.builds = resp.builds;

      if ($location.search().current) {
        $scope.setCurrentBuild($location.search().current, false);
      } else if ($scope.builds.length > 0) {
        $scope.setCurrentBuild($scope.builds[$scope.builds.length - 1].id, true);
      }
    });
  };

  fetchRepository();
}

function RepoAdminCtrl($scope, Restangular, ApiService, KeyService, $routeParams, $rootScope, $location) {
  var namespace = $routeParams.namespace;
  var name = $routeParams.name;

  $scope.permissions = {'team': [], 'user': []};
  $scope.logsShown = 0;
  $scope.deleting = false;
  
  $scope.permissionCache = {};

  $scope.githubRedirectUri = KeyService.githubRedirectUri;
  $scope.githubClientId = KeyService.githubClientId;

  $scope.buildEntityForPermission = function(name, permission, kind) {
    var key = name + ':' + kind;
    if ($scope.permissionCache[key]) {
      return $scope.permissionCache[key];
    }

    return $scope.permissionCache[key] = {
      'kind': kind,
      'name': name,
      'is_robot': permission.is_robot,
      'is_org_member': permission.is_org_member
    };
  };

  $scope.loadLogs = function() {
    $scope.logsShown++;
  };

  $scope.grantRole = function() {
    $('#confirmaddoutsideModal').modal('hide');
    var entity = $scope.currentAddEntity;
    $scope.addRole(entity.name, 'read', entity.kind, entity.is_org_member)
    $scope.currentAddEntity = null;
  };

  $scope.addNewPermission = function(entity) {
    // Don't allow duplicates.
    if (!entity || !entity.kind || $scope.permissions[entity.kind][entity.name]) { return; }

    if (entity.is_org_member === false) {
      $scope.currentAddEntity = entity;
      $('#confirmaddoutsideModal').modal('show');
      return;
    }

    $scope.addRole(entity.name, 'read', entity.kind);
  };

  $scope.deleteRole = function(entityName, kind) {
    var permissionDelete = Restangular.one(getRestUrl('repository', namespace, name, 'permissions', kind, entityName));
    permissionDelete.customDELETE().then(function() {
      delete $scope.permissions[kind][entityName];
    }, function(resp) {
      if (resp.status == 409) {
        $scope.changePermError = resp.data || '';
        $('#channgechangepermModal').modal({});       
      } else {
        $('#cannotchangeModal').modal({});
      }
    });
  };

  $scope.addRole = function(entityName, role, kind) {
    var permission = {
      'role': role,
    };

    var permissionPost = Restangular.one(getRestUrl('repository', namespace, name, 'permissions', kind, entityName));
    permissionPost.customPOST(permission).then(function(result) {
      $scope.permissions[kind][entityName] = result;
    }, function(result) {
      $('#cannotchangeModal').modal({});
    });
  };

  $scope.roles = [
      { 'id': 'read', 'title': 'Read', 'kind': 'success' },
      { 'id': 'write', 'title': 'Write', 'kind': 'success' },
      { 'id': 'admin', 'title': 'Admin', 'kind': 'primary' }
  ];

  $scope.setRole = function(role, entityName, kind) {
    var permission = $scope.permissions[kind][entityName];
    var currentRole = permission.role;
    permission.role = role;
   
    var permissionPut = Restangular.one(getRestUrl('repository', namespace, name, 'permissions', kind, entityName));
    permissionPut.customPUT(permission).then(function() {}, function(resp) {
      $scope.permissions[kind][entityName] = {'role': currentRole};
      $scope.changePermError = null;
      if (resp.status == 409 || resp.data) {
        $scope.changePermError = resp.data || '';
        $('#channgechangepermModal').modal({});
      } else {
        $('#cannotchangeModal').modal({});
      }
    });
  };

  $scope.createToken = function() {
    var friendlyName = {
      'friendlyName': $scope.newToken.friendlyName
    };

    var params = {'repository': namespace + '/' + name};
    ApiService.createToken(friendlyName, params).then(function(newToken) {
      $scope.newToken.friendlyName = '';
      $scope.createTokenForm.$setPristine();
      $scope.tokens[newToken.code] = newToken;
    });
  };

  $scope.deleteToken = function(tokenCode) {
    var params = {
      'repository': namespace + '/' + name,
      'code': tokenCode
    };

    ApiService.deleteToken(null, params).then(function() {
      delete $scope.tokens[tokenCode];
    });
  };

  $scope.changeTokenAccess = function(tokenCode, newAccess) {
    var role = {
      'role': newAccess
    };

    var params = {
      'repository': namespace + '/' + name,
      'code': tokenCode
    };

    ApiService.changeToken(role, params).then(function(updated) {
      $scope.tokens[updated.code] = updated;
    });
  };

  $scope.shownTokenCounter = 0;

  $scope.showToken = function(tokenCode) {
    $scope.shownToken = $scope.tokens[tokenCode];
    $scope.shownTokenCounter++;
  };

  $scope.askChangeAccess = function(newAccess) {
    $('#make' + newAccess + 'Modal').modal({});
  };

  $scope.changeAccess = function(newAccess) {
    $('#make' + newAccess + 'Modal').modal('hide');

    var visibility = {
      'visibility': newAccess
    };

    var params = {
      'repository': namespace + '/' + name
    };

    ApiService.changeRepoVisibility(visibility, params).then(function() {
      $scope.repo.is_public = newAccess == 'public';
    }, function() {
      $('#cannotchangeModal').modal({});
    });
  };

  $scope.askDelete = function() {
    $('#confirmdeleteModal').modal({});
  };

  $scope.deleteRepo = function() {
    $('#confirmdeleteModal').modal('hide');

    var params = {
      'repository': namespace + '/' + name
    };

    $scope.deleting = true;
    ApiService.deleteRepository(null, params).then(function() {
      $scope.repo = null;
      
      setTimeout(function() {
        document.location = '/repository/';
      }, 1000);
    }, function() {
      $scope.deleting = true;
      $('#cannotchangeModal').modal({});
    });
  };

  $scope.loadWebhooks = function() {
    var params = {
      'repository': namespace + '/' + name
    };

    $scope.newWebhook = {};
    $scope.webhooksResource = ApiService.listWebhooksAsResource(params).get(function(resp) {
      $scope.webhooks = resp.webhooks;
      return $scope.webhooks;
    });
  };

  $scope.createWebhook = function() {
    if (!$scope.newWebhook.url) {
      return;
    }

    var params = {
      'repository': namespace + '/' + name
    };

    ApiService.createWebhook($scope.newWebhook, params).then(function(resp) {
      $scope.webhooks.push(resp);
      $scope.newWebhook.url = '';
      $scope.createWebhookForm.$setPristine();
    });
  };

  $scope.deleteWebhook = function(webhook) {
    var params = {
      'repository': namespace + '/' + name,
      'public_id': webhook.public_id
    };

    ApiService.deleteWebhook(null, params).then(function(resp) {
      $scope.webhooks.splice($scope.webhooks.indexOf(webhook), 1);
    });
  };

  $scope.showBuild = function(buildInfo) {
    $location.path('/repository/' + namespace + '/' + name + '/build');
    $location.search('current', buildInfo.id);
  };

  $scope.loadTriggerBuildHistory = function(trigger) {
    trigger.$loadingHistory = true;

    var params = {
      'repository': namespace + '/' + name,
      'trigger_uuid': trigger.id,
      'limit': 3
    };

    ApiService.listTriggerRecentBuilds(null, params).then(function(resp) {
      trigger.$builds = resp['builds'];
      trigger.$loadingHistory = false;
    });
  };

  $scope.loadTriggers = function() {
    var params = {
      'repository': namespace + '/' + name
    };

    $scope.triggersResource = ApiService.listBuildTriggersAsResource(params).get(function(resp) {
      $scope.triggers = resp.triggers;

      // Check to see if we need to setup any trigger.
      var newTriggerId = $routeParams.new_trigger;
      if (newTriggerId) {
        for (var i = 0; i < $scope.triggers.length; ++i) {
          var trigger = $scope.triggers[i];
          if (trigger['id'] == newTriggerId && !trigger['is_active']) {
            $scope.setupTrigger(trigger);
            break;
          }
        }
      }

      return $scope.triggers;
    });
  };

  $scope.setupTrigger = function(trigger) {
    $scope.triggerSetupReady = false;
    $scope.currentSetupTrigger = trigger;
    $('#setupTriggerModal').modal({});
    $('#setupTriggerModal').on('hidden.bs.modal', function () {
      $scope.$apply(function() {
        $scope.cancelSetupTrigger();
      });
    });
  };

  $scope.finishSetupTrigger = function(trigger) {
    $('#setupTriggerModal').modal('hide');
    $scope.currentSetupTrigger = null;

    var params = {
      'repository': namespace + '/' + name,
      'trigger_uuid': trigger.id
    };

    ApiService.activateBuildTrigger(trigger['config'], params).then(function(resp) {
      trigger['is_active'] = true;      
    }, function(resp) {
      $scope.triggers.splice($scope.triggers.indexOf(trigger), 1);
      bootbox.dialog({
        "message": resp['data']['message'] || 'The build trigger setup could not be completed',
        "title": "Could not activate build trigger",
        "buttons": {
          "close": {
            "label": "Close",
            "className": "btn-primary"
          }
        }
      });
    });
  };

  $scope.cancelSetupTrigger = function() {
    if (!$scope.currentSetupTrigger) { return; }

    $('#setupTriggerModal').modal('hide');
    $scope.deleteTrigger($scope.currentSetupTrigger);
    $scope.currentSetupTrigger = null;
  };

  $scope.startTrigger = function(trigger) {
    var params = {
      'repository': namespace + '/' + name,
      'trigger_uuid': trigger.id
    };

    ApiService.manuallyStartBuildTrigger(null, params).then(function(resp) {
      window.console.log(resp);
      var url = '/repository/' + namespace + '/' + name + '/build?current=' + resp['id'];
      document.location = url;
    }, function(resp) {
      bootbox.dialog({
        "message": resp['message'] || 'The build could not be started',
        "title": "Could not start build",
        "buttons": {
          "close": {
            "label": "Close",
            "className": "btn-primary"
          }
        }
      });
    });
  };

  $scope.deleteTrigger = function(trigger) {
    var params = {
      'repository': namespace + '/' + name,
      'trigger_uuid': trigger.id
    };

    ApiService.deleteBuildTrigger(null, params).then(function(resp) {
      $scope.triggers.splice($scope.triggers.indexOf(trigger), 1);
    });
  };

  var fetchTokens = function() {
    var params = {
      'repository': namespace + '/' + name
    };

    ApiService.listRepoTokens(null, params).then(function(resp) {
      $scope.tokens = resp.tokens;
    }, function() {
      $scope.tokens = null;
    });
  };

  var fetchPermissions = function(kind) {
    var permissionsFetch = Restangular.one('repository/' + namespace + '/' + name + '/permissions/' + kind + '/');
    permissionsFetch.get().then(function(resp) {
      $scope.permissions[kind] = resp.permissions;
    }, function() {
      $scope.permissions[kind] = null;
    });
  };

  var fetchRepository = function() {
    var params = {
      'repository': namespace + '/' + name
    };

    $scope.repository = ApiService.getRepoAsResource(params).get(function(repo) {
      if (!repo.can_admin) {
        $rootScope.title = 'Forbidden';
        $scope.accessDenied = true;
        return;
      }

      $scope.repo = repo;
      $rootScope.title = 'Settings - ' + namespace + '/' + name;
      $rootScope.description = 'Administrator settings for ' + namespace + '/' + name +
          ': Permissions, webhooks and other settings';

      // Fetch all the permissions and token info for the repository.
      fetchPermissions('user');
      fetchPermissions('team');
      fetchTokens();

      $('.info-icon').popover({
        'trigger': 'hover',
        'html': true
      });

      return $scope.repo;
    });
  };

  // Fetch the repository.
  fetchRepository();
}

function UserAdminCtrl($scope, $timeout, $location, ApiService, PlanService, UserService, CookieService, KeyService,
    $routeParams, $http) {
  if ($routeParams['migrate']) {
    $('#migrateTab').tab('show')
  }

  UserService.updateUserIn($scope, function(user) {
    $scope.askForPassword = user.askForPassword;
    $scope.cuser = jQuery.extend({}, user);

    for (var i = 0; i < $scope.cuser.logins.length; i++) {
      if ($scope.cuser.logins[i].service == 'github') {
        var githubId = $scope.cuser.logins[i].service_identifier;
        $http.get('https://api.github.com/user/' + githubId).success(function(resp) {
          $scope.githubLogin = resp.login;
        });
      }
    }
  });

  $scope.readyForPlan = function() {
    // Show the subscribe dialog if a plan was requested.
    return $routeParams['plan'];
  };

  $scope.loading = true;
  $scope.updatingUser = false;
  $scope.changePasswordSuccess = false;
  $scope.changeEmailSent = false;
  $scope.convertStep = 0;
  $scope.org = {};
  $scope.githubRedirectUri = KeyService.githubRedirectUri;
  $scope.githubClientId = KeyService.githubClientId;

  $('.form-change').popover();

  $scope.logsShown = 0;
  $scope.invoicesShown = 0;
  
  $scope.loadLogs = function() {
    if (!$scope.hasPaidBusinessPlan) { return; }
    $scope.logsShown++;
  };

  $scope.loadInvoices = function() {
    if (!$scope.hasPaidBusinessPlan) { return; }
    $scope.invoicesShown++;
  };

  $scope.planChanged = function(plan) {
    $scope.hasPaidPlan = plan && plan.price > 0;
    $scope.hasPaidBusinessPlan = PlanService.isOrgCompatible(plan) && plan.price > 0;
  };

  $scope.showConvertForm = function() {
    PlanService.getMatchingBusinessPlan(function(plan) {
      $scope.org.plan = plan;
    });

    PlanService.getPlans(function(plans) {
      $scope.orgPlans = plans;
    });
      
    $scope.convertStep = 1;
  };

  $scope.convertToOrg = function() {
    $('#reallyconvertModal').modal({});
  };

  $scope.reallyConvert = function() {
    $scope.loading = true;

    var data = {
      'adminUser': $scope.org.adminUser,
      'adminPassword': $scope.org.adminPassword,
      'plan': $scope.org.plan.stripeId
    };

    ApiService.convertUserToOrganization(data).then(function(resp) {
      CookieService.putPermanent('quay.namespace', $scope.cuser.username);
      UserService.load();
      $location.path('/');
    }, function(resp) {
      $scope.loading = false;
      if (resp.data.reason == 'invaliduser') {
        $('#invalidadminModal').modal({});
      } else {
        $('#cannotconvertModal').modal({});
      }
    });
  };

  $scope.changeEmail = function() {
    $('#changeEmailForm').popover('hide');
    $scope.updatingUser = true;
    $scope.changeEmailSent = false;

    ApiService.changeUserDetails($scope.cuser).then(function() {
      $scope.updatingUser = false;
      $scope.changeEmailSent = true;
      $scope.sentEmail = $scope.cuser.email;

      // Reset the form.
      $scope.cuser.repeatEmail = '';
      $scope.changeEmailForm.$setPristine();
    }, function(result) {
      $scope.updatingUser = false;

      $scope.changeEmailError = result.data.message;
      $timeout(function() {
        $('#changeEmailForm').popover('show');
      });
    });
  };

  $scope.changePassword = function() {
    $('#changePasswordForm').popover('hide');
    $scope.updatingUser = true;
    $scope.changePasswordSuccess = false;

    ApiService.changeUserDetails($scope.cuser).then(function() {
      $scope.updatingUser = false;
      $scope.changePasswordSuccess = true;

      // Reset the form
      $scope.cuser.password = '';
      $scope.cuser.repeatPassword = '';
      $scope.changePasswordForm.$setPristine();

      // Reload the user.
      UserService.load();
    }, function(result) {
      $scope.updatingUser = false;

      $scope.changePasswordError = result.data.message;
      $timeout(function() {
        $('#changePasswordForm').popover('show');
      });
    });
  };
}

function ImageViewCtrl($scope, $routeParams, $rootScope, $timeout, ApiService, ImageMetadataService) {  
  var namespace = $routeParams.namespace;
  var name = $routeParams.name;
  var imageid = $routeParams.image;

  $scope.getFormattedCommand = ImageMetadataService.getFormattedCommand;

  $scope.parseDate = function(dateString) {
    return Date.parse(dateString);
  };

  $scope.getFolder = function(filepath) {
    var index = filepath.lastIndexOf('/');
    if (index < 0) {
      return '';
    }
    return filepath.substr(0, index + 1);
  };

  $scope.getFolders = function(filepath) {
    var index = filepath.lastIndexOf('/');
    if (index < 0) {
      return '';
    }
    
    return filepath.substr(0, index).split('/');
  };

  $scope.getFilename = function(filepath) {
    var index = filepath.lastIndexOf('/');
    if (index < 0) {
      return filepath;
    }
    return filepath.substr(index + 1);
  };

  $scope.setFolderFilter = function(folderPath, index) {
    var parts = folderPath.split('/');
    parts = parts.slice(0, index + 1);
    $scope.setFilter(parts.join('/'));
  };

  $scope.setFilter = function(filter) {
    $scope.search = {};
    $scope.search['$'] = filter;
    document.getElementById('change-filter').value = filter;
  };
  
  $scope.initializeTree = function() {
    if ($scope.tree) { return; }
    
    $scope.tree = new ImageFileChangeTree($scope.image, $scope.combinedChanges);
    $timeout(function() {
      $scope.tree.draw('changes-tree-container');
    }, 10);
  };

  var fetchImage = function() {
    var params = {
      'repository': namespace + '/' + name,
      'image_id': imageid  
    };

    $scope.image = ApiService.getImageAsResource(params).get(function(image) {
      $scope.repo = {
        'name': name,
        'namespace': namespace
      };

      $rootScope.title = 'View Image - ' + image.id;
      $rootScope.description = 'Viewing docker image ' + image.id + ' under repository ' + namespace + '/' + name +
        ': Image changes tree and list view';

      // Fetch the image's changes.
      fetchChanges();

      $('#copyClipboard').clipboardCopy();

      return image;
    });
  };

  var fetchChanges = function() {
    var params = {
      'repository': namespace + '/' + name,
      'image_id': imageid  
    };

    ApiService.getImageChanges(null, params).then(function(changes) {
      var combinedChanges = [];
      var addCombinedChanges = function(c, kind) {
        for (var i = 0;  i < c.length; ++i) {
          combinedChanges.push({ 
            'kind': kind,
            'file': c[i]
          });
        }
      };

      addCombinedChanges(changes.added, 'added');
      addCombinedChanges(changes.removed, 'removed');
      addCombinedChanges(changes.changed, 'changed');

      $scope.combinedChanges = combinedChanges;
      $scope.imageChanges = changes;
    });
  };

  // Fetch the image.
  fetchImage();
}

function V1Ctrl($scope, $location, UserService) {
  UserService.updateUserIn($scope);
}

function NewRepoCtrl($scope, $location, $http, $timeout, UserService, ApiService, PlanService) {
  UserService.updateUserIn($scope);

  $scope.repo = {
    'is_public': 1,
    'description': '',
    'initialize': false
  };

  // Watch the namespace on the repo. If it changes, we update the plan and the public/private
  // accordingly.
  $scope.isUserNamespace = true;
  $scope.$watch('repo.namespace', function(namespace) {
    // Note: Can initially be undefined.
    if (!namespace) { return; }
    
    var isUserNamespace = (namespace == $scope.user.username);

    $scope.checkingPlan = true;
    $scope.planRequired = null;
    $scope.isUserNamespace = isUserNamespace;

    if (isUserNamespace) {
      // Load the user's subscription information in case they want to create a private
      // repository.
      ApiService.getUserPrivateCount().then(function(resp) {
        if (resp.privateCount + 1 > resp.reposAllowed) {
          PlanService.getMinimumPlan(resp.privateCount + 1, false, function(minimum) {
            $scope.planRequired = minimum;
          });
        }

        $scope.checkingPlan = false;
      }, function() {
        $scope.planRequired = {};
        $scope.checkingPlan = false;
      });
    } else {
      ApiService.getOrganizationPrivateAllowed(null, {'orgname': namespace}).then(function(resp) {
        $scope.planRequired = resp.privateAllowed ? null : {};
        $scope.checkingPlan = false;
      }, function() {
        $scope.planRequired = {};
        $scope.checkingPlan = false;
      });

      // Auto-set to private repo.
      $scope.repo.is_public = '0';
    }
  });

  $scope.changeNamespace = function(namespace) {
    $scope.repo.namespace = namespace;
  };

  $scope.handleBuildStarted = function() {
    var repo = $scope.repo;
    $location.path('/repository/' + repo.namespace + '/' + repo.name);
  };

  $scope.handleBuildFailed = function(message) {
    var repo = $scope.repo;

    bootbox.dialog({
      "message": message,
      "title": "Could not start Dockerfile build",
      "buttons": {
        "close": {
          "label": "Close",
          "className": "btn-primary",
          "callback": function() {
            $scope.$apply(function() {
              $location.path('/repository/' + repo.namespace + '/' + repo.name);
            });
          }
        }
      }
    });
    
    return true;
  };

  $scope.createNewRepo = function() {
    $('#repoName').popover('hide');

    $scope.creating = true;
    var repo = $scope.repo;
    var data = {
      'namespace': repo.namespace,
      'repository': repo.name,
      'visibility': repo.is_public == '1' ? 'public' : 'private',
      'description': repo.description
    };

    ApiService.createRepo(data).then(function(created) {
      $scope.creating = false;
      $scope.created = created;

      // Repository created. Start the upload process if applicable.
      if ($scope.repo.initialize) {
        $scope.createdForBuild = created;
        return;
      }

      // Otherwise, redirect to the repo page.
      $location.path('/repository/' + created.namespace + '/' + created.name);
    }, function(result) {
      $scope.creating = false;
      $scope.createError = result.data ? result.data.message : 'Cannot create repository';
      $timeout(function() {
        $('#repoName').popover('show');
      });
    });
  };

  $scope.upgradePlan = function() {
    var callbacks = {
      'started': function() { $scope.planChanging = true; },
      'opened': function() { $scope.planChanging = true; },
      'closed': function() { $scope.planChanging = false; },
      'success': subscribedToPlan,
      'failure': function(resp) {
        $('#couldnotsubscribeModal').modal();
        $scope.planChanging = false;
      }
    };

    PlanService.changePlan($scope, null, $scope.planRequired.stripeId, callbacks);
  };

  var subscribedToPlan = function(sub) {
    $scope.planChanging = false;
    $scope.subscription = sub;

    PlanService.getPlan(sub.plan, function(subscribedPlan) {
      $scope.subscribedPlan = subscribedPlan;
      $scope.planRequired = null;

      // Check to see if the current plan allows for an additional private repository to
      // be created.
      var privateAllowed = $scope.subscription.usedPrivateRepos < $scope.subscribedPlan.privateRepos;
      if (!privateAllowed) {
        // If not, find the minimum repository that does.
        PlanService.getMinimumPlan($scope.subscription.usedPrivateRepos + 1, !$scope.isUserNamespace, function(minimum) {
          $scope.planRequired = minimum;
        });
      }
    });
  };
}

function OrgViewCtrl($rootScope, $scope, ApiService, $routeParams) {
  var orgname = $routeParams.orgname;

  $scope.TEAM_PATTERN = TEAM_PATTERN;
  $rootScope.title = 'Loading...';

  $scope.teamRoles = [
      { 'id': 'member', 'title': 'Member', 'kind': 'default' },
      { 'id': 'creator', 'title': 'Creator', 'kind': 'success' },
      { 'id': 'admin', 'title': 'Admin', 'kind': 'primary' }
  ];
  
  $scope.setRole = function(role, teamname) {    
    var previousRole = $scope.organization.teams[teamname].role;
    $scope.organization.teams[teamname].role = role;

    var params = {
      'orgname': orgname,
      'teamname': teamname
    };

    var data = $scope.organization.teams[teamname];

    ApiService.updateOrganizationTeam(data, params).then(function(resp) {
    }, function(resp) {     
      $scope.organization.teams[teamname].role = previousRole;
      $scope.roleError = resp.data || '';
      $('#cannotChangeTeamModal').modal({});
    });
  };

  $scope.createTeam = function(teamname) {
    if (!teamname) {
      return;
    }

    if ($scope.organization.teams[teamname]) {
      $('#team-' + teamname).removeClass('highlight');
      setTimeout(function() {
        $('#team-' + teamname).addClass('highlight');
      }, 10);
      return;
    }

    createOrganizationTeam(ApiService, orgname, teamname, function(created) {
      $scope.organization.teams[teamname] = created;
    });
  };

  $scope.askDeleteTeam = function(teamname) {
    $scope.currentDeleteTeam = teamname;
    $('#confirmdeleteModal').modal({});
  };

  $scope.deleteTeam = function() {
    $('#confirmdeleteModal').modal('hide');
    if (!$scope.currentDeleteTeam) { return; }

    var teamname = $scope.currentDeleteTeam;
    var params = {
      'orgname': orgname,
      'teamname': teamname
    };

    ApiService.deleteOrganizationTeam(null, params).then(function() {
      delete $scope.organization.teams[teamname];
      $scope.currentDeleteTeam = null;
    }, function() {
      $('#cannotchangeModal').modal({});
      $scope.currentDeleteTeam = null;
    });
  };

  var loadOrganization = function() {
    $scope.orgResource = ApiService.getOrganizationAsResource({'orgname': orgname}).get(function(org) {
      $scope.organization = org;
      $rootScope.title = orgname;
      $rootScope.description = 'Viewing organization ' + orgname;

      $('.info-icon').popover({
        'trigger': 'hover',
        'html': true
      });
    });
  };

  // Load the organization.
  loadOrganization();
}

function OrgAdminCtrl($rootScope, $scope, $timeout, Restangular, $routeParams, UserService, PlanService, ApiService) {
  var orgname = $routeParams.orgname;

  // Load the list of plans.
  PlanService.getPlans(function(plans) {
    $scope.plans = plans;
    $scope.plan_map = {};

    for (var i = 0; i < plans.length; ++i) {
      $scope.plan_map[plans[i].stripeId] = plans[i];
    }
  });

  $scope.orgname = orgname;
  $scope.membersLoading = true;
  $scope.membersFound = null;
  $scope.invoiceLoading = true;
  $scope.logsShown = 0;
  $scope.invoicesShown = 0;
  $scope.changingOrganization = false;
  
  $scope.loadLogs = function() {
    $scope.logsShown++;
  };

  $scope.loadInvoices = function() {
    $scope.invoicesShown++;
  };

  $scope.planChanged = function(plan) {
    $scope.hasPaidPlan = plan && plan.price > 0;
  };

  $scope.$watch('organizationEmail', function(e) {
    $('#changeEmailForm').popover('hide');
  });

  $scope.changeEmail = function() {
    $scope.changingOrganization = true;
    var params = {
      'orgname': orgname
    };

    var data = {
      'email': $scope.organizationEmail
    };

    ApiService.changeOrganizationDetails(data, params).then(function(org) {
      $scope.changingOrganization = false;
      $scope.changeEmailForm.$setPristine();
      $scope.organization = org;
    }, function(result) {
      $scope.changingOrganization = false;
      $scope.changeEmailError = result.data.message;
      $timeout(function() {
        $('#changeEmailForm').popover('show');
      });
    });
  };

  $scope.loadMembers = function() {
    if ($scope.membersFound) { return; }
    $scope.membersLoading = true;

    var params = {
      'orgname': orgname
    };

    ApiService.getOrganizationMembers(null, params).then(function(resp) {
      var membersArray = [];
      for (var key in resp.members) {
        if (resp.members.hasOwnProperty(key)) {
          membersArray.push(resp.members[key]);
        }
      }

      $scope.membersFound = membersArray;
      $scope.membersLoading = false;
    });
  };

  var loadOrganization = function() {
    $scope.orgResource = ApiService.getOrganizationAsResource({'orgname': orgname}).get(function(org) {
      if (org && org.is_admin) {
        $scope.organization = org;
        $scope.organizationEmail = org.email;
        $rootScope.title = orgname + ' (Admin)';
        $rootScope.description = 'Administration page for organization ' + orgname;
      }
    });
  };

  // Load the organization.
  loadOrganization();
}

function TeamViewCtrl($rootScope, $scope, Restangular, ApiService, $routeParams) {
  var teamname = $routeParams.teamname;
  var orgname = $routeParams.orgname;

  $scope.orgname = orgname;
  $scope.teamname = teamname;

  $rootScope.title = 'Loading...';

  $scope.addNewMember = function(member) {
    if (!member || $scope.members[member.name]) { return; }

    var params = {
      'orgname': orgname,
      'teamname': teamname,
      'membername': member.name
    };

    ApiService.updateOrganizationTeamMember(null, params).then(function(resp) {
      $scope.members[member.name] = resp;
    }, function() {
      $('#cannotChangeMembersModal').modal({});
    });
  };

  $scope.removeMember = function(username) {
    var params = {
      'orgname': orgname,
      'teamname': teamname,
      'membername': username
    };

    ApiService.deleteOrganizationTeamMember(null, params).then(function(resp) {
      delete $scope.members[username];
    }, function() {
      $('#cannotChangeMembersModal').modal({});
    });
  };

  $scope.updateForDescription = function(content) {
    $scope.organization.teams[teamname].description = content;

    var params = {
      'orgname': orgname,
      'teamname': teamname
    };

    var teaminfo = $scope.organization.teams[teamname];
    ApiService.updateOrganizationTeam(teaminfo, params).then(function(resp) {
    }, function() {
      $('#cannotChangeTeamModal').modal({});
    });
  };

  var loadOrganization = function() {
    $scope.orgResource = ApiService.getOrganizationAsResource({'orgname': orgname}).get(function(org) {
      $scope.organization = org;
      $scope.team = $scope.organization.teams[teamname];
      $rootScope.title = teamname + ' (' + $scope.orgname + ')';
      $rootScope.description = 'Team management page for team ' + teamname + ' under organization ' + $scope.orgname;
      loadMembers();
      return org;
    });
  };

  var loadMembers = function() {
    var params = {
      'orgname': orgname,
      'teamname': teamname
    };

    $scope.membersResource = ApiService.getOrganizationTeamMembersAsResource(params).get(function(resp) {
      $scope.members = resp.members;
      $scope.canEditMembers = resp.can_edit;
        
      $('.info-icon').popover({
        'trigger': 'hover',
        'html': true
      });

      return resp.members;
    });
  };

  // Load the organization.
  loadOrganization();
}

function OrgsCtrl($scope, UserService) {
  UserService.updateUserIn($scope);
  browserchrome.update();
}

function NewOrgCtrl($scope, $routeParams, $timeout, $location, UserService, PlanService, ApiService, CookieService) {
  UserService.updateUserIn($scope);

  var requested = $routeParams['plan'];

  // Load the list of plans.
  PlanService.getPlans(function(plans) {
    $scope.plans = plans;
    $scope.currentPlan = null;
    if (requested) {
      PlanService.getPlan(requested, function(plan) {
        $scope.currentPlan = plan;
      });
    }
  });

  $scope.signedIn = function() {
    PlanService.handleNotedPlan();
  };

  $scope.signinStarted = function() {
    PlanService.getMinimumPlan(1, true, function(plan) {
      PlanService.notePlan(plan.stripeId);
    });
  };

  $scope.setPlan = function(plan) {
    $scope.currentPlan = plan;
  };

  $scope.createNewOrg = function() {
    $('#orgName').popover('hide');

    $scope.creating = true;
    var org = $scope.org;
    var data = {
      'name': org.name,
      'email': org.email
    };

    ApiService.createOrganization(data).then(function(created) {
      $scope.created = created;

      // Reset the organizations list.
      UserService.load();

      // Set the default namesapce to the organization.
      CookieService.putPermanent('quay.namespace', org.name);

      var showOrg = function() {
        $scope.creating = false;
        $location.path('/organization/' + org.name + '/');
      };

      // If the selected plan is free, simply move to the org page.
      if ($scope.currentPlan.price == 0) {
        showOrg();
        return;
      }

      // Otherwise, show the subscribe for the plan.
      $scope.creating = true;
      var callbacks = {
        'opened': function() { $scope.creating = true; },
        'closed': showOrg,
        'success': showOrg,
        'failure': showOrg
      };

      PlanService.changePlan($scope, org.name, $scope.currentPlan.stripeId, callbacks);
    }, function(result) {
      $scope.creating = false;
      $scope.createError = result.data.message || result.data;
      $timeout(function() {
        $('#orgName').popover('show');
      });
    });
  };
}


function OrgMemberLogsCtrl($scope, $routeParams, $rootScope, $timeout, Restangular, ApiService) {
  var orgname = $routeParams.orgname;
  var membername = $routeParams.membername;

  $scope.orgname = orgname;
  $scope.memberInfo = null;
  $scope.ready = false;

  var loadOrganization = function() {
    $scope.orgResource = ApiService.getOrganizationAsResource({'orgname': orgname}).get(function(org) {
      $scope.organization = org;
      return org;
    });
  };

  var loadMemberInfo = function() {
    var params = {
      'orgname': orgname,
      'membername': membername
    };

    $scope.memberResource = ApiService.getOrganizationMemberAsResource(params).get(function(resp) {
      $scope.memberInfo = resp.member;

      $rootScope.title = 'Logs for ' + $scope.memberInfo.username + ' (' + $scope.orgname + ')';
      $rootScope.description = 'Shows all the actions of ' + $scope.memberInfo.username +
         ' under organization ' + $scope.orgname;

      $timeout(function() {
        $scope.ready = true;
      });

      return resp.member;
    });   
  };

  // Load the org info and the member info.
  loadOrganization();
  loadMemberInfo();
}