FIFA Manager PWA

stat1-teams-registered.ts

/**
 * How many teams are registered
 */
howManyTeamsAreRegistered(): number {
  return this.teamsService.getElements().length;
}

stat2-players-registered.ts

/**
 * Return how many players are registered
 */
howManyPlayersAreRegistered(): number {
  // Iterate teams
  return this.teamsService.getElements()
  // Return the amount of players of a team
  .map((team: Team) => team.players.getElements().length)
  // Sum the numbers of players
  .reduce((prevNumPlayers, currentNumPlayers) => prevNumPlayers + currentNumPlayers );
}

stat3-youngest-player.ts

/**
 * Iterate all players of the tournament
 *
 * Observables was used because flatMap is not native yet
 */
allPlayers(): Observable<Player> {
  // Iterate teams
  return Observable.of(this.teamsService.getElements())
    // Iterate teams as a single element
    .switchMap((teams: Array<Team>) => teams)
    // Iterate the players of the Team as a single element
    .switchMap((team: Team) => team.players.getElements());
}

/**
 * Find the youngest player in all teams.
 *
 * Observables was used because flatMap is not native yet
 */
calculateYoungestPlayer(): Observable<Player> {
  // Iterate players
  return this.allPlayers()
    // Calculate the youngest player
    .reduce((youngestPlayer: Player, currentPlayer: Player) => {
      if (youngestPlayer.birthDate > currentPlayer.birthDate) {
        return youngestPlayer;
      }

      return currentPlayer;
    });
}

/**
 * Variable to store the youngest player asynchronously
 */
let youngestPlayer: Player;
  
// Find the youngest player
this.calculateYoungestPlayer()
  .subscribe(
    (youngestPlayer: Player) => this.youngestPlayer = youngestPlayer
  );

stat4-oldest-player.ts

/**
 * Iterate all players of the tournament
 *
 * Observables was used because flatMap is not native yet
 */
allPlayers(): Observable<Player> {
  // Iterate teams
  return Observable.of(this.teamsService.getElements())
    // Iterate teams as a single element
    .switchMap((teams: Array<Team>) => teams)
    // Iterate the players of the Team as a single element
    .switchMap((team: Team) => team.players.getElements());
}

/**
 * Find the oldest player in all teams.
 *
 * Observables was used because flatMap is not native yet
 */
calculateOldestPlayer(): Observable<Player> {
  // Iterate players
  return this.allPlayers()
    // Calculate the OLDEST player
    .reduce((oldestPlayer: Player, currentPlayer: Player) => {
      if (oldestPlayer.birthDate < currentPlayer.birthDate) {
        return oldestPlayer;
      }

      return currentPlayer;
    });
}

/**
 * Variable to store the oldest player asynchronously
 */
oldestPlayer: Player;
                                                           
// Find the oldest player
this.calculateOldestPlayer()
  .subscribe(
    (oldestPlayer: Player) => this.oldestPlayer = oldestPlayer
  );

stat5-non-titular-players.ts

/**
 * Iterate all players of the tournament
 *
 * Observables was used because flatMap is not native yet
 */
allPlayers(): Observable<Player> {
  // Iterate teams
  return Observable.of(this.teamsService.getElements())
    // Iterate teams as a single element
    .switchMap((teams: Array<Team>) => teams)
    // Iterate the players of the Team as a single element
    .switchMap((team: Team) => team.players.getElements());
}

/**
 * Calculate How Many non Players Are.
 *
 * Observables was used because flatMap is not native yet
 */
calculateNonTitularPlayers(): Observable<number> {
  return this.allPlayers()
    // Sum how many non titulars players are
    .reduce((nonTitular: number, currentPlayer: Player) => {
      // If the players is titular just return, else, sum one and return
      return currentPlayer.titular ? nonTitular : ++nonTitular;
    }, 0);
}

/**
 * Number of non titular players are
 */
nonTitularPlayers: Number | String;

// Calculate non titular players
this.calculateNonTitularPlayers()
  .subscribe(
    (nonTitulars: number) => {
      this.nonTitularPlayers = nonTitulars;

      // Calculate average of non titulars players per team
      this.AverageNonTitularPlayers = nonTitulars / this.howManyTeamsAreRegistered();
    }
  );

stat6-average-non-titular-players-each-team.ts

/**
 * Iterate all players of the tournament
 *
 * Observables was used because flatMap is not native yet
 */
allPlayers(): Observable<Player> {
  // Iterate teams
  return Observable.of(this.teamsService.getElements())
    // Iterate teams as a single element
    .switchMap((teams: Array<Team>) => teams)
    // Iterate the players of the Team as a single element
    .switchMap((team: Team) => team.players.getElements());
}

/**
 * How many teams are registered
 */
howManyTeamsAreRegistered(): number {
  return this.teamsService.getElements().length;
}
  
/**
 * Calculate How Many non Players Are.
 *
 * Observables was used because flatMap is not native yet
 */
calculateNonTitularPlayers(): Observable<number> {
  return this.allPlayers()
    // Sum how many non titulars players are
    .reduce((nonTitular: number, currentPlayer: Player) => {
      // If the players is titular just return, else, sum one and return
      return currentPlayer.titular ? nonTitular : ++nonTitular;
    }, 0);
}

/**
 * Average of non titular players on all the teams
 */
AverageNonTitularPlayers: Number | String;

// Calculate non titular players
this.calculateNonTitularPlayers()
  .subscribe(
    (nonTitulars: number) => {
      // Calculate average of non titulars players per team
      this.AverageNonTitularPlayers = nonTitulars / this.howManyTeamsAreRegistered();
    }
  );