public static getPlayerEarningsDisplay(player: Player, team: Team, movies: Movie[],
    bonusAmount: number): PlayerEarningsDisplay {
    const earningRows: PlayerEarningsDisplayRow[] = [];
    const moviesObj = Enumerable.from(movies);
    const moviesSorted = moviesObj.orderBy((m) => m.id).toArray();
    const totalShares = moviesObj.toDictionary((k) => k.id, (v) =>
      MovieHelpers.totalSharesByMovie(Enumerable.from(v.shares), Enumerable.from(team.players)));
    const movieEarnings = moviesObj.toDictionary((k) => k.id, (v) =>
      MovieHelpers.maxEarningByMovie(Enumerable.from(v.earnings)));
    const bestAndWorstMovies = MovieHelpers.bestAndWorstMovies(moviesObj);
    let bonus1 = false;
    let bonus2 = false;

    for (const movie of moviesSorted) {
      let playerEarned = 0;
      const shares = Enumerable.from(movie.shares);
      const playerShares = shares.firstOrDefault((s) => s.playerId === player.id);
      const movieEarned = movieEarnings.get(movie.id);
      const sharesTotal = totalShares.get(movie.id);

      if (playerShares && sharesTotal > 0) {
        playerEarned = (playerShares.numShares / sharesTotal) * movieEarned;
      }

      bonus1 = bonus1 || bestAndWorstMovies.bestMovies.any((m) => m.id === movie.id) && player.bonus1Id === movie.id;
      bonus2 = bonus2 || bestAndWorstMovies.worstMovies.any((m) => m.id === movie.id) && player.bonus2Id === movie.id;

      earningRows.push(new PlayerEarningsDisplayRow(movie, playerShares.numShares, playerEarned,
        player.bonus1Id === movie.id, player.bonus2Id === movie.id));
    }

    return new PlayerEarningsDisplay(earningRows, bonus1, bonus2, bonusAmount);
  }

  public static getStandingsDisplay(moviesArr: Movie[], players: Player[], bonusAmount: number): StandingsDisplay[] {
    const movies = Enumerable.from(moviesArr);
    const totalShares = movies.toDictionary((k) => k.id, (v) =>
      MovieHelpers.totalSharesByMovie(Enumerable.from(v.shares), Enumerable.from(players)));
    const movieEarnings = movies.toDictionary((k) => k.id, (v) =>
      MovieHelpers.maxEarningByMovie(Enumerable.from(v.earnings)));
    const bestAndWorstMovies = MovieHelpers.bestAndWorstMovies(movies);
    const standings: StandingsDisplay[] = [];

    for (const player of players) {
      let total = 0;
      let bonus1 = false;
      let bonus2 = false;
      let sharesUsed = 0;
      const bonus1Id = player.bonus1Id !== undefined ? player.bonus1Id : 0;
      const bonus2Id = player.bonus2Id !== undefined ? player.bonus2Id : 0;

      for (const movie of moviesArr) {
        const playerShares = Enumerable.from(movie.shares).firstOrDefault((s) => s.playerId === player.id);
        const movieEarned = movieEarnings.get(movie.id);
        const shareTotal = totalShares.get(movie.id);
        if (playerShares && movieEarned > 0 && shareTotal > 0) {
          total += (playerShares.numShares / shareTotal) * movieEarned;
          sharesUsed += playerShares.numShares;
        }

        if (bestAndWorstMovies.bestMovies.any((m) => m.id === movie.id) && bonus1Id === movie.id) {
          bonus1 = true;
          total += bonusAmount;
        }
        if (bestAndWorstMovies.worstMovies.any((m) => m.id === movie.id) && bonus2Id === movie.id) {
          bonus2 = true;
          total += bonusAmount;
        }
      }

      total = Math.round(total);
      standings.push(new StandingsDisplay(player, bonus1, bonus2, sharesUsed, total));
    }

    const sortedStandings = Enumerable.from(standings).orderByDescending((s) => s.total).toArray();
    let rank = 1;
    let lastRank = 1;
    let lastTotal = 0;
    for (const standing of sortedStandings) {
      if (standing.total === lastTotal) {
        standing.rank = lastRank;
      } else {
        standing.rank = rank;
        lastRank = rank;
      }
      rank++;
      lastTotal = standing.total;
    }

    return sortedStandings;
  }

  public static getEarningsDisplay(movies: Movie[], players: Player[]): EarningsDisplay[] {
    const earnings: EarningsDisplay[] = [];
    const bestAndWorstMovies = MovieHelpers.bestAndWorstMovies(Enumerable.from(movies));
    const playersEnum = Enumerable.from(players);

    for (const movie of movies) {
      const shares = MovieHelpers.totalSharesByMovie(Enumerable.from(movie.shares), playersEnum);
      const gross = MovieHelpers.maxEarningByMovie(Enumerable.from(movie.earnings));
      const isBestMovie = bestAndWorstMovies.bestMovies.any((m) => m.id === movie.id);
      const isWorstMovie = bestAndWorstMovies.worstMovies.any((m) => m.id === movie.id);
      earnings.push(new EarningsDisplay(movie, isBestMovie, isWorstMovie, shares, gross));
    }

    return earnings;
  }

    it('should infer types for from clause', () => {
        let strEnum: IEnumerable<string> = Enumerable.from(['foo', 'bar', 'oops']);
        let filtered: IEnumerable<string> = strEnum.where(x => x.indexOf('o') !== -1);
        let selected: IEnumerable<number> = filtered.select(str => str.length);

        expect(selected.toArray()).to.deep.equal([3, 4])
    });

 Enumerable.from(searchProperties).forEach(p=> {
     var trimmed: string = p.substr(findBy.length, p.length);
     var splits = Enumerable.from(trimmed.split("And")).select(s => {
         return s.toLowerCase();
     }).toArray();
     namePropMap.push({ key: p, args: splits });
 });

  public static getMovieEarningsChartData(movie: Movie): string {
    const earningPoints = Enumerable.from(movie.earnings).where((e) => e.createdAt.getDay() === 0)
      .orderBy((e) => e.createdAt).select((e) => ({ t: moment(e.createdAt).format("LL"), y: e.gross }))
      .toArray();

    return JSON.stringify(earningPoints);
  }

    async getEventsByEntityId(entityId: string): Promise<EventStream> {
        let domainEvents = Enumerable
            .from(this.events)
            .where(evt => evt.entityId === entityId)
            .toArray();

        return new EventStream(domainEvents);
    }

 async getEventsByEntityType(entityType: string): Promise<EventStream[]> {
     return Enumerable
         .from(this.events)
         .where(evt => evt.entityType === entityType)
         .groupBy((evt: IDomainEvent<any>) => evt.entityType)
         .select(grp => new EventStream(grp.toArray()))
         .toArray();
 }