Major update

functions/season-loader/seasonLoader/function.json

@@ -0,0 +1,20 @@
+{
+  "bindings": [
+    {
+      "authLevel": "function",
+      "type": "httpTrigger",
+      "direction": "in",
+      "name": "req",
+      "methods": [
+        "get",
+        "post"
+      ]
+    },
+    {
+      "type": "http",
+      "direction": "out",
+      "name": "res"
+    }
+  ],
+  "scriptFile": "../dist/seasonLoader/index.js"
+}

functions/season-loader/seasonLoader/index.ts

@@ -0,0 +1,258 @@
+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;