constructor(private _ea: EventAggregator){
   this._ea.subscribe(Events.bootstrapChosen, () => {
     this.router.navigate('bootstrap');
   });
   this._ea.subscribe(Events.polymerChosen, () => {
     this.router.navigate('polymer');
   });
 }

 constructor(private api: AdnAPI, private ea: EventAggregator) {
     this.posts = new PostsModel(ea);
     this.streamOptions = new StreamOptions(false, '', 0, false);
     this.postPosted = ea.subscribe(PostPosted, () => this.loadStream(this.streamOptions, false));
     this.refreshView = ea.subscribe(RefreshView, () => this.loadStream(this.streamOptions, false));
     this.loadMore = ea.subscribe(LoadMore, () => this.loadStream(this.streamOptions, true));
     this.streamOptions.loadToStreamMarker = true;
     this.loadUntilStreamMarker = ea.subscribe(LoadUntilStreamMarker, () => this.loadStream(this.streamOptions, true));
 }

 constructor(af: ApiFactory, private events: EventAggregator) {
   this.api = af.create(Product);
   this.api.all()
     .then(prods => this.products = prods);
   
   this.unsubs = [
     this.events.subscribe('product.saved', prod => this.add(prod)),
     this.events.subscribe('product.removed', prod => this.remove(prod))
   ];
 }

    constructor(ea: EventAggregator, logger: Log, element: Element, animator: VelocityAnimator) {
        this.ea = ea;
        this.logger = logger;
        this.element = element;
        this.animator = animator;

        this.ea.subscribe(MinimizeWidge.EventTypes.MINIMIZE, context => { this.onMinimize(context) });
        this.ea.subscribe(MinimizeWidge.EventTypes.RESTORE, context => { this.onRestore(context) });

        this.isContentHidden = false;
    }

  constructor(eventAggregator: EventAggregator, api: WebAPI) {
    this.ea = eventAggregator;
    this.api = api;

    this.ea.subscribe(ContactViewed, msg => {
      this.select(msg.contact)
    });
    this.ea.subscribe(ContactUpdated, msg => {
      let id = msg.contact.id;
      let found = this.contacts.find(x => x.id == id);
      Object.assign(found, msg.contact);
    });
  }

    prepare() {
        if (this.router.isConfigured) {
            return;
        }

        this.router.configure((config: RouterConfiguration) => {
            config.title = 'Aurelia';
            config.map([
                { route: ['', 'login'], name: 'login', moduleId: 'login' },
                { route: 'page1', name: 'page1', moduleId: 'page1', settings: { auth: true } },
                { route: 'page2', name: 'page2', moduleId: 'page2', settings: { auth: true } }
            ]);
            config.addAuthorizeStep(AuthPlugin);

            return config;
        });

        let callback = (eventArgs: Object, name) => {
            logger.warn(eventArgs['instruction']['config']['name'], name);
        };

        this.eventAggregator.subscribe('router:navigation:processing', callback);
        this.eventAggregator.subscribe('router:navigation:error', callback);
        this.eventAggregator.subscribe('router:navigation:canceled', callback);
        this.eventAggregator.subscribe('router:navigation:success', callback);
        this.eventAggregator.subscribe('router:navigation:complete', callback);
    }

 frameworkSelected(framework:string) {
     switch (framework) {
         case FrameworkType.Polymer:
             this._ea.publish(Events.polymerChosen);
             break;
         case FrameworkType.Bootstrap:
             this._ea.publish(Events.bootstrapChosen);
             break;
     }
 }

      .then((response: any) => {
        this.meta = response.content.meta;
        this.isRequesting = false;
        this.ea.publish(new ApiStatus('Post Reported', { status: 'success' }));
        return response.content.data;

      }).catch((err: any) => {

 }).then(() => {
     if (so.loadToStreamMarker && this.api.meta.min_id > this.api.meta.marker.last_read_id) {
         this.loadStream(this.streamOptions, true);
     } else {
         this.ea.publish(new RefreshedView());
     }
 });

    return Promise.resolve().then(() => {
      if (this.isNavigating && !instructionCount) {
        // ts complains about inconsistent returns without void 0
        return void 0;
      }

      let instruction = this._queue.shift();
      this._queue.length = 0;

      if (!instruction) {
        // ts complains about inconsistent returns without void 0
        return void 0;
      }

      this.isNavigating = true;

      let navtracker: number = this.history.getState('NavigationTracker');
      let currentNavTracker = this.currentNavigationTracker;

      if (!navtracker && !currentNavTracker) {
        this.isNavigatingFirst = true;
        this.isNavigatingNew = true;
      } else if (!navtracker) {
        this.isNavigatingNew = true;
      } else if (!currentNavTracker) {
        this.isNavigatingRefresh = true;
      } else if (currentNavTracker < navtracker) {
        this.isNavigatingForward = true;
      } else if (currentNavTracker > navtracker) {
        this.isNavigatingBack = true;
      } if (!navtracker) {
        navtracker = Date.now();
        this.history.setState('NavigationTracker', navtracker);
      }
      this.currentNavigationTracker = navtracker;

      instruction.previousInstruction = this.currentInstruction;

      let maxInstructionCount = this.maxInstructionCount;

      if (!instructionCount) {
        this.events.publish(RouterEvent.Processing, { instruction });
      } else if (instructionCount === maxInstructionCount - 1) {
        logger.error(`${instructionCount + 1} navigation instructions have been attempted without success. Restoring last known good location.`);
        restorePreviousLocation(this);
        return this._dequeueInstruction(instructionCount + 1);
      } else if (instructionCount > maxInstructionCount) {
        throw new Error('Maximum navigation attempts exceeded. Giving up.');
      }

      let pipeline = this.pipelineProvider.createPipeline(!this.couldDeactivate);

      return pipeline
        .run(instruction)
        .then(result => processResult(instruction, result, instructionCount, this))
        .catch(error => {
          return { output: error instanceof Error ? error : new Error(error) } as PipelineResult;
        })
        .then(result => resolveInstruction(instruction, result, !!instructionCount, this));
    });