constructor(private $sce: ISCEService,
              private app: Application,
              private authenticationService: AuthenticationService) {

    const user: string[] = this.authenticationService.getAuthenticatedUser().name.split('@');
    const url = NetflixSettings.tableau.appSourceUrl.replace('${app}', this.app.name).replace('${user}', user[0]);
    this.srcUrl = this.$sce.trustAsResourceUrl(url);
  }

    .controller('ScriptStageCtrl', ($scope: IScope, stage: IStage, authenticationService: AuthenticationService) => {
      $scope.stage = stage;
      $scope.stage.failPipeline = ($scope.stage.failPipeline === undefined ? true : $scope.stage.failPipeline);
      $scope.stage.waitForCompletion = ($scope.stage.waitForCompletion === undefined ? true : $scope.stage.waitForCompletion);

      if (!$scope.stage.user) {
        $scope.stage.user = authenticationService.getAuthenticatedUser().name;
      }

      $scope.viewState = {
        loading: false
      };
    });

  constructor(private $scope: any,
              private $uibModal: IModalService,
              private stage: IIsolatedTestingTargetStage,
              private namingService: NamingService,
              private providerSelectionService: any,
              authenticationService: AuthenticationService,
              private cloudProviderRegistry: CloudProviderRegistry,
              private serverGroupCommandBuilder: any,
              private serverGroupReader: ServerGroupReader,
              private awsServerGroupTransformer: any) {

    const user = authenticationService.getAuthenticatedUser();
    $scope.stage = stage;
    $scope.stage.owner = $scope.stage.owner || (user.authenticated ? user.name : null);

    $scope.stage.username = user.name.includes('@') ? user.name.substring(0, user.name.lastIndexOf('@')) : user.name;
  }

 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();
   });
 }

      return (exception: Error, cause: string) => {

        $delegate(exception, cause);
        const $http = $injector.get('$http'); // using injector access to avoid a circular dependency
        if (SETTINGS.alert) {

          let message: string = exception.message;
          if (!message) {
            try {
              message = JSON.stringify(exception);
            } catch (e) {
              message = '[No message available - could not convert exception to JSON string]';
            }
          }

          const payload = {
            alertName: 'Spinnaker',
            details: {
              url: location.href,
              user: authenticationService.getAuthenticatedUser().name,
              version: currentVersion.version,
            },
            exception: {
              classes: [exception.name || '[no name on exception]'],
              messages: [message],
              stackTraces: [exception.stack || '[no stacktrace available]'],
              callerClass: 'Spinnaker',
              callerMethod: '[see stack trace]',
            },
            actions: [
              {
                action: 'email',
                suppressTimeSecs: SETTINGS.alert.throttleInSeconds,
                to: SETTINGS.alert.recipients,
                subject: SETTINGS.alert.subject || '[Spinnaker] Error in Deck',
                htmlTemplate: SETTINGS.alert.template || 'spinnaker_deck_error',
                incidentKey: exception.message,
              }
            ],
          };

          $http.post(SETTINGS.alert.url, payload);
        }
      };

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

 public triggerPipeline(applicationName: string, pipelineName: string, body: any = {}): ng.IPromise<void> {
   body.user = this.authenticationService.getAuthenticatedUser().name;
   return this.API.one('pipelines').one(applicationName).one(pipelineName).data(body).post();
 }

 public startAdHocPipeline(body: any): ng.IPromise<void> {
   body.user = this.authenticationService.getAuthenticatedUser().name;
   return this.API.one('pipelines').one('start').data(body).post();
 }