public getStrategiesForApplication(applicationName: string): IPromise<IPipeline[]> {
   return this.API.one('applications').one(applicationName).all('strategyConfigs').getList()
     .then((pipelines: IPipeline[]) => {
     pipelines.forEach(p => p.stages = p.stages || []);
     return this.sortPipelines(pipelines);
   });
 }

 public cancelTask(applicationName: string, taskId: string): IPromise<void> {
   return this.API.one('applications', applicationName).all('tasks').one(taskId, 'cancel').put().then(() =>
     this.taskReader.getTask(taskId).then((task) =>
       this.taskReader.waitUntilTaskMatches(task, (updatedTask) => updatedTask.status === 'CANCELED')
     )
   );
 }

 public triggerPipeline(applicationName: string, pipelineName: string, body: any = {}): IPromise<string> {
   body.user = this.authenticationService.getAuthenticatedUser().name;
   return this.API.one('pipelines').one(applicationName).one(pipelineName).data(body).post()
     .then((result: ITriggerPipelineResponse) => {
       return result.ref.split('/').pop();
   });
 }

 public getAllSecurityGroups(): IPromise<ISecurityGroupsByAccountSourceData> {
   // Because these are cached in local storage, we unfortunately need to remove the moniker, as it triples the size
   // of the object being stored, which blows out our LS quota for a sufficiently large footprint
   const cache = this.infrastructureCaches.get('securityGroups');
   const cached = !!cache ? cache.get('allGroups') : null;
   if (cached) {
     return this.$q.resolve(cached);
   }
   return this.API.one('securityGroups').useCache().get()
     .then((groupsByAccount: ISecurityGroupsByAccountSourceData) => {
         Object.keys(groupsByAccount).forEach(account => {
           Object.keys(groupsByAccount[account]).forEach(provider => {
             Object.keys(groupsByAccount[account][provider]).forEach(region => {
               groupsByAccount[account][provider][region].forEach(group => {
                 delete group.moniker;
               })
             })
           })
         });
       if (cache) {
         cache.put('allGroups', groupsByAccount);
       }
       return groupsByAccount;
     });
 }

 public loadLoadBalancers(applicationName: string): IPromise<ILoadBalancerSourceData[]> {
   return this.API.one('applications', applicationName).all('loadBalancers').getList()
     .then((loadBalancers: ILoadBalancerSourceData[]) => {
       loadBalancers = this.loadBalancerTransformer.normalizeLoadBalancerSet(loadBalancers);
       return this.$q.all(loadBalancers.map(lb => this.normalizeLoadBalancer(lb)));
     });
 }

 public getServiceAccounts(): ng.IPromise<string[]> {
   if (!this.settings.feature.fiatEnabled) {
     return this.$q.resolve([]);
   } else {
     return this.API.one('auth').one('user').one('serviceAccounts').get();
   }
 }

 public getPipelineTemplateFromSourceUrl(source: string, executionId?: String, pipelineConfigId?: string): IPromise<IPipelineTemplate> {
   return this.API.one('pipelineTemplates').one('resolve').withParams({ source, executionId, pipelineConfigId }).get()
     .then((template: IPipelineTemplate) => {
       template.selfLink = source;
       return template;
     });
 }

 public listAllAccounts(provider: string = null, providerVersion: string = null): IPromise<IAccountDetails[]> {
   return this.API.one('credentials')
     .useCache()
     .withParams({ expand: true })
     .get()
     .then((accounts: IAccountDetails[]) => accounts.filter(account => !provider || account.type === provider))
     .then((accounts: IAccountDetails[]) => accounts.filter(account => !providerVersion || account.providerVersion === providerVersion));
 }

  public listAccounts(provider: string = null): ng.IPromise<IAccount[]> {

    let result: ng.IPromise<IAccount[]> = this.API.one('credentials').useCache().get();
    if (provider) {
      result = result.then((accounts: IAccount[]) => accounts.filter((account: IAccount) => account.type === provider));
    }

    return result;
  }

 public getManifest(account: string,
                    location: string,
                    name: string): IPromise<IManifest> {
   return this.API.all('manifests')
     .all(account)
     .all(location)
     .one(name)
     .get();
 }