mlb-gameday-dotnet-react/functions/season-loader/seasonLoader/index.ts

import { AzureFunction, Context, HttpRequest } from '@azure/functions';
import { HubConnection, HubConnectionBuilder } from '@microsoft/signalr';
import axios, { AxiosResponse } from 'axios';
import { IGame } from '../models/IGame';

const initialzeSignalRConnection = async (context: Context): Promise<HubConnection> => {
    const connection: HubConnection = new HubConnectionBuilder()
        .withUrl('http://localhost:5580/hubs/season')
        .build();

    try {
        await connection.start().catch((error) => context.log(error.toString()));
        context.log('connected')
        return Promise.resolve<HubConnection>(connection);
    } catch (error) {
        return Promise.reject(error);
    }
}

const createGames = async (dates: any[], context: Context): Promise<void> => {
    const connection = await initialzeSignalRConnection(context);
    let count = 0;

    try {
        for (let d = 0; d < dates.length; d++) {
            const games = dates[d].games;
            const gamesToAdd: IGame[] = [];

            for (let g = 0; g < games.length; g++) {
                const game: any = games[g];
                const gameToAdd: IGame = {};

                if (game.gamePk) {
                    gameToAdd.gamePk = game.gamePk;
                }

                if (game.link) {
                    gameToAdd.link = game.link;
                }

                if (game.gameType) {
                    gameToAdd.gameType = game.gameType;
                }

                if (game.season) {
                    gameToAdd.season = game.season;
                }

                if (game.gameDate) {
                    gameToAdd.gameDate = game.gameDate;
                }

                if (game.officialDate) {
                    gameToAdd.officialDate = game.officialDate;
                }

                if (game.status.abstractGameState) {
                    gameToAdd.statusAbstractGameState = game.status.abstractGameState;
                }

                if (game.status.codedGameState) {
                    gameToAdd.statusCodedGameState = game.status.codedGameState;
                }

                if (game.status.detailedState) {
                    gameToAdd.statusDetailedState = game.status.detailedState;
                }

                if (game.status.statusCode) {
                    gameToAdd.statusStatusCode = game.status.statusCode;
                }

                if (game.status.startTimeTBD) {
                    gameToAdd.statusStartTimeTbd = game.status.startTimeTBD;
                }

                if (game.status.abstractGameCode) {
                    gameToAdd.statusAbstractGameCode = game.status.abstractGameCode;
                }

                if (game.teams.away.leagueRecord.wins) {
                    gameToAdd.teamsAwayLeagueRecordWins = game.teams.away.leagueRecord.wins;
                }

                if (game.teams.away.leagueRecord.losses) {
                    gameToAdd.teamsAwayLeagueRecordLosses = game.teams.away.leagueRecord.losses;
                }

                if (game.teams.away.leagueRecord.pct) {
                    gameToAdd.teamsAwayLeagueRecordPct = parseFloat(game.teams.away.leagueRecord.pct);
                }

                if (game.teams.away.team.id) {
                    gameToAdd.teamsAwayTeamId = game.teams.away.team.id;
                }

                if (game.teams.away.splitSquad) {
                    gameToAdd.teamsAwaySplitSquad = game.teams.away.splitSquad;
                }

                if (game.teams.away.seriesNumber) {
                    gameToAdd.teamsAwaySeriesNumber = game.teams.away.seriesNumber;
                }

                if (game.teams.home.leagueRecord.wins) {
                    gameToAdd.teamsHomeLeagueRecordWins = game.teams.home.leagueRecord.wins;
                }

                if (game.teams.home.leagueRecord.losses) {
                    gameToAdd.teamsHomeLeagueRecordLosses = game.teams.home.leagueRecord.losses;
                }

                if (game.teams.home.leagueRecord.pct) {

                    gameToAdd.teamsHomeLeagueRecordPct = parseFloat(game.teams.home.leagueRecord.pct);
                }

                if (game.teams.home.team.id) {
                    gameToAdd.teamsHomeTeamId = game.teams.home.team.id;
                }

                if (game.teams.home.splitSquad) {
                    gameToAdd.teamsHomeSplitSquad = game.teams.home.splitSquad;
                }

                if (game.teams.home.seriesNumber) {
                    gameToAdd.teamsHomeSeriesNumber = game.teams.home.seriesNumber;
                }

                if (game.venue.id) {
                    gameToAdd.venueId = game.venue.id;
                }

                if (game.content.link) {
                    gameToAdd.contentLink = game.content.link;
                }

                if (game.isTie) {
                    gameToAdd.isTie = game.isTie;
                }

                if (game.gameNumber) {
                    gameToAdd.gameNumber = game.gameNumber;
                }

                if (game.publicFacing) {
                    gameToAdd.publicFacing = game.publicFacing;
                }

                if (game.doubleHeader) {
                    gameToAdd.doubleHeader = game.doubleHeader;
                }

                if (game.gamedayType) {
                    gameToAdd.gamedayType = game.gamedayType;
                }

                if (game.tieBreaker) {
                    gameToAdd.tieBreaker = game.tiebreaker;
                }

                if (game.calendarEventID) {
                    gameToAdd.calendarEventId = game.calendarEventID;
                }

                if (game.seasonDisplay) {
                    gameToAdd.seasonDisplay = game.seasonDisplay;
                }

                if (game.dayNight) {
                    gameToAdd.dayNight = game.dayNight;
                }

                if (game.scheduledInnings) {
                    gameToAdd.scheduledInnings = game.scheduledInnings;
                }

                if (game.reverseHomeAwayStatus) {
                    gameToAdd.reverseHomeAwayStatus = game.reverseHomeAwayStatus;
                }

                if (game.inningBreakLength) {
                    gameToAdd.inningBreakLength = game.inningBreakLength;
                }

                if (game.gamesInSeries) {
                    gameToAdd.gamesInSeries = game.gamesInSeries;
                }

                if (game.seriesGameNumber) {
                    gameToAdd.seriesGameNumber = game.seriesGameNumber;
                }

                if (game.seriesDescription) {
                    gameToAdd.seriesDescription = game.seriesDescription;
                }

                if (game.recordSource) {
                    gameToAdd.recordSource = game.recordSource;
                }

                if (game.ifNecessary) {
                    gameToAdd.ifNecessary = game.ifNecessary;
                }

                if (game.ifNecessaryDescription) {
                    gameToAdd.ifNecessaryDescription = game.ifNecessaryDescription;
                }
                
                gamesToAdd.push(gameToAdd);
            }
            
            await axios.post('http://localhost:5520/api/games', gamesToAdd);

            count += 1;
            context.log(`${count} of ${dates.length}`);

            await connection.invoke('SendSeasonMessage', {
                totalDates: dates.length,
                datesCompleted: count
            });
        }

        return Promise.resolve();
    } catch (error) {
        return Promise.reject(error);
    }
}

const httpTrigger: AzureFunction = async (context: Context, req: HttpRequest): Promise<void> => {
    const year = req.query.year;

    if (!year) {
        context.res = {
            status: 500,
            body: 'Season year required.'
        }
    } else {
        try {
            const response: AxiosResponse = await axios.get(`https://statsapi.mlb.com/api/v1/schedule?sportId=1&startDate=${year}-01-01&endDate=${year}-12-31`);
            const dates = response.data.dates;
            
            await createGames(dates, context);

            context.res = {
                status: 201
            }

        } catch (error) {
            context.res = {
                status: 500,
                body: error
            }
        }
    }
};

export default httpTrigger;