private normalizeTargetGroup(targetGroup: ITargetGroup): IPromise<ITargetGroup> {
    this.normalizeServerGroups(targetGroup.serverGroups, targetGroup, 'targetGroups', 'TargetGroup');

    const activeServerGroups = filter(targetGroup.serverGroups, { isDisabled: false });
    targetGroup.provider = targetGroup.type;
    targetGroup.instances = chain(activeServerGroups)
      .map('instances')
      .flatten<IInstance>()
      .value();
    targetGroup.detachedInstances = chain(activeServerGroups)
      .map('detachedInstances')
      .flatten<IInstance>()
      .value();
    this.updateHealthCounts(targetGroup);

    return $q.all([VpcReader.listVpcs(), AccountService.listAllAccounts()]).then(([vpcs, accounts]) => {
      const tg = this.addVpcNameToContainer(targetGroup)(vpcs) as ITargetGroup;

      tg.serverGroups = tg.serverGroups.map(serverGroup => {
        const account = accounts.find(x => x.name === serverGroup.account);
        const cloudProvider = serverGroup.cloudProvider || (account && account.cloudProvider);

        serverGroup.instances.forEach(instance => {
          instance.cloudProvider = cloudProvider;
          instance.provider = cloudProvider;
        });

        return { ...serverGroup, cloudProvider };
      });

      return tg;
    });
  }

 public static populateTargetGroups(
   application: Application,
   serverGroup: IAmazonServerGroup,
 ): IPromise<ITargetGroup[]> {
   return $q
     .all([AccountService.getAccountDetails(serverGroup.account), application.getDataSource('loadBalancers').ready()])
     .then(data => {
       const awsAccount = (data[0] && data[0].awsAccount) || serverGroup.account;
       const loadBalancers: IAmazonApplicationLoadBalancer[] = application
         .getDataSource('loadBalancers')
         .data.filter(
           lb => lb.loadBalancerType === 'application' || lb.loadBalancerType === 'network',
         ) as IAmazonApplicationLoadBalancer[];
       const targetGroups = serverGroup.targetGroups
         .map((targetGroupName: string) => {
           const allTargetGroups = flatten(loadBalancers.map(lb => lb.targetGroups || []));
           const targetGroup = allTargetGroups.find(
             tg => tg.name === targetGroupName && tg.region === serverGroup.region && tg.account === awsAccount,
           );
           return this.buildTargetGroup(targetGroup, serverGroup);
         })
         .filter(tg => tg);
       return targetGroups;
     });
 }

      ).then((details: IAmazonServerGroup) => {
        // it's possible the summary was not found because the clusters are still loading
        Object.assign(details, summary, { account: serverGroupInfo.accountId });

        const serverGroup = AwsReactInjector.awsServerGroupTransformer.normalizeServerGroupDetails(details);

        AccountService.getAccountDetails(serverGroup.account).then(accountDetails => {
          serverGroup.accountDetails = accountDetails;
          observer.next(serverGroup);
        });

        if (!isEmpty(serverGroup)) {
          const vpc = serverGroup.asg ? serverGroup.asg.vpczoneIdentifier : '';

          if (vpc !== '') {
            const subnetId = vpc.split(',')[0];
            SubnetReader.listSubnets().then((subnets: ISubnet[]) => {
              const subnet = subnets.find(s => s.id === subnetId);
              serverGroup.subnetType = subnet.purpose;
              observer.next(serverGroup);
            });
          }

          serverGroup.disabledDate = AutoScalingProcessService.getDisabledDate(serverGroup);

          observer.next(serverGroup);
        } else {
          autoClose();
        }
      }, autoClose);

 public setStageRegion(): void {
   const selected = this.$scope.accounts.find(account => account.name === this.$scope.stage.credentials);
   if (selected && selected.name) {
     AccountService.getAccountDetails(selected.name).then((accountDetails: IAppengineAccount) => {
       this.$scope.stage.region = accountDetails.region;
     });
   }
 }

  public static buildNewManifestCommand(
    app: Application,
    sourceManifest?: any,
    sourceMoniker?: IMoniker,
    sourceAccount?: string,
  ): IPromise<IKubernetesManifestCommandData> {
    if (sourceManifest != null && has(sourceManifest, ['metadata', 'annotations', LAST_APPLIED_CONFIGURATION])) {
      sourceManifest = load(sourceManifest.metadata.annotations[LAST_APPLIED_CONFIGURATION]);
    }

    const dataToFetch = {
      accounts: AccountService.getAllAccountDetailsForProvider('kubernetes', 'v2'),
      artifactAccounts: AccountService.getArtifactAccounts(),
    };

    // TODO(dpeach): if no callers of this method are Angular controllers,
    // $q.all may be safely replaced with Promise.all.
    return $q
      .all(dataToFetch)
      .then((backingData: { accounts: IAccountDetails[]; artifactAccounts: IArtifactAccount[] }) => {
        const { accounts, artifactAccounts } = backingData;

        const account = accounts.some(a => a.name === sourceAccount)
          ? accounts.find(a => a.name === sourceAccount).name
          : accounts.length
          ? accounts[0].name
          : null;

        let manifestArtifactAccount: string = null;
        const [artifactAccountData] = artifactAccounts;
        if (artifactAccountData) {
          manifestArtifactAccount = artifactAccountData.name;
        }

        const cloudProvider = 'kubernetes';
        const moniker = sourceMoniker || {
          app: app.name,
        };

        const relationships = {
          loadBalancers: [] as string[],
          securityGroups: [] as string[],
        };

        const versioned: any = null;

        return {
          command: {
            cloudProvider,
            manifest: null,
            manifests: Array.isArray(sourceManifest)
              ? sourceManifest
              : sourceManifest != null
              ? [sourceManifest]
              : null,
            relationships,
            moniker,
            account,
            versioned,
            manifestArtifactAccount,
          },
          metadata: {
            backingData,
          },
        } as IKubernetesManifestCommandData;
      });
  }

  public buildNewManifestCommand(app: Application, sourceManifest?: any, sourceMoniker?: IMoniker): IPromise<IKubernetesManifestCommandData> {
    const dataToFetch = {
      accounts: this.accountService.getAllAccountDetailsForProvider('kubernetes', 'v2'),
      artifactAccounts: this.accountService.getArtifactAccounts(),
    };

    return this.$q.all(dataToFetch)
      .then((backingData: any) => {
        const accountData = backingData.accounts[0];
        let account: string = null;
        if (accountData) {
          account = accountData.name;
        }

        let manifestArtifactAccount: string = null;
        const artifactAccountData = backingData.artifactAccounts[0];
        if (artifactAccountData) {
          manifestArtifactAccount = artifactAccountData.name;
        }

        const manifest: any = null;
        const manifests: any = null;
        const manifestText = !sourceManifest ? '' : dump(sourceManifest);
        const cloudProvider = 'kubernetes';
        const moniker = sourceMoniker || {
          app: app.name,
        };

        const relationships = {
          loadBalancers: [] as string[],
          securityGroups: [] as string[],
        };

        const versioned: any = null;

        return {
          command: {
            cloudProvider,
            manifest,
            manifests,
            relationships,
            moniker,
            account,
            versioned,
            manifestArtifactAccount,
          },
          metadata: {
            backingData,
            manifestText,
          }
        } as IKubernetesManifestCommandData;
      });
  }

  public buildNewServerGroupCommand(app: Application,
                                    selectedProvider = 'appengine',
                                    mode = 'create'): IPromise<IAppengineServerGroupCommand> {
    const dataToFetch = {
      accounts: this.accountService.getAllAccountDetailsForProvider('appengine'),
    };

    const viewState: IViewState = {
      mode: mode,
      submitButtonLabel: this.getSubmitButtonLabel(mode),
      disableStrategySelection: mode === 'create' ? true : false,
    };

    return this.$q.all(dataToFetch)
      .then((backingData: any) => {
        const credentials: string = this.getCredentials(backingData.accounts, app);
        const region: string = this.getRegion(backingData.accounts, credentials);

        return {
          application: app.name,
          backingData,
          viewState,
          credentials,
          region,
          selectedProvider,
          interestingHealthProviderNames: [],
        } as IAppengineServerGroupCommand;
      });
  }

  // TODO (Bruno Carrier): Why do we need to inject an Application into this constructor so that the app works?  This is strange, and needs investigating
  public configureCommand(command: IEcsServerGroupCommand): IPromise<void> {
    this.applyOverrides('beforeConfiguration', command);
    command.toggleSuspendedProcess = (process: string): void => {
      command.suspendedProcesses = command.suspendedProcesses || [];
      const processIndex = command.suspendedProcesses.indexOf(process);
      if (processIndex === -1) {
        command.suspendedProcesses.push(process);
      } else {
        command.suspendedProcesses.splice(processIndex, 1);
      }
    };

    command.processIsSuspended = (process: string): boolean => command.suspendedProcesses.includes(process);

    command.onStrategyChange = (strategy: IDeploymentStrategy): void => {
      // Any strategy other than None or Custom should force traffic to be enabled
      if (strategy.key !== '' && strategy.key !== 'custom') {
        command.suspendedProcesses = (command.suspendedProcesses || []).filter(p => p !== 'AddToLoadBalancer');
      }
    };

    command.regionIsDeprecated = (): boolean => {
      return has(command, 'backingData.filtered.regions') &&
        command.backingData.filtered.regions.some((region) => region.name === command.region && region.deprecated);
    };

    return this.$q.all({
      credentialsKeyedByAccount: this.accountService.getCredentialsKeyedByAccount('ecs'),
      loadBalancers: this.loadBalancerReader.listLoadBalancers('ecs'),
      subnets: this.subnetReader.listSubnets(),
      iamRoles: this.iamRoleReader.listRoles('ecs'),
      ecsClusters: this.ecsClusterReader.listClusters(),
      metricAlarms: this.metricAlarmReader.listMetricAlarms(),
    }).then((backingData: Partial<IEcsServerGroupCommandBackingData>) => {
      let loadBalancerReloader = this.$q.when(null);
      backingData.accounts = keys(backingData.credentialsKeyedByAccount);
      backingData.filtered = {} as IEcsServerGroupCommandBackingDataFiltered;
      command.backingData = backingData as IEcsServerGroupCommandBackingData;
      this.configureVpcId(command);
      this.configureAvailableIamRoles(command);
      this.configureAvailableMetricAlarms(command);
      this.configureAvailableEcsClusters(command);

      if (command.loadBalancers && command.loadBalancers.length) {
        // verify all load balancers are accounted for; otherwise, try refreshing load balancers cache
        const loadBalancerNames = this.getLoadBalancerNames(command);
        if (intersection(loadBalancerNames, command.loadBalancers).length < command.loadBalancers.length) {
          loadBalancerReloader = this.refreshLoadBalancers(command, true);
        }
      }

      return this.$q.all([loadBalancerReloader]).then(() => {
        this.applyOverrides('afterConfiguration', command);
        this.attachEventHandlers(command);
      });
    });
  }

    return this.certificateReader.listCertificatesByProvider('aws').then((certificates: IAmazonCertificate[]) => {
      // This account grouping should really go into clouddriver but since it's not, put it here for now.
      return this.accountService.getAllAccountDetailsForProvider('aws').then((allAccountDetails) => {
        const accountIdToName = allAccountDetails.reduce((acc, accountDetails) => {
          acc[accountDetails.accountId] = accountDetails.name;
          return acc;
        }, {} as {[id: string]: string});

        const sortedCertificates = sortBy(certificates, 'serverCertificateName');
        return groupBy(sortedCertificates, (cert) => {
          const [, , , , accountId] = cert.arn.split(':');
          return accountIdToName[accountId] || 'unknown';
        });
      });
    });

 protected setAccounts(): IPromise<void> {
   return this.accountService.listAccounts('appengine').then((accounts: IAppengineAccount[]) => {
     this.$scope.accounts = accounts;
   });
 }