volleyballsimtypes 0.0.1

package/src/data/transformers/performance-stats.ts

@@ -0,0 +1,40 @@
+import { PerformanceStatsAttributes, PerformanceStatsModel } from '../models'
+import { PerformanceStats, Player } from '../../service'
+
+function transformToAttributes (player: Player): PerformanceStatsAttributes {
+  return {
+    player_id: player.id,
+    back_attack: player.stats.backAttack,
+    block: player.stats.block,
+    awareness: player.stats.awareness,
+    defense: player.stats.defense,
+    jump: player.stats.jump,
+    pass: player.stats.pass,
+    serve: player.stats.serve,
+    reception: player.stats.reception,
+    setting: player.stats.setting,
+    spike: player.stats.spike,
+    stamina: player.stats.stamina
+  }
+}
+
+function transformToObject (model: PerformanceStatsModel): PerformanceStats {
+  return new PerformanceStats({
+    awareness: model.awareness,
+    defense: model.defense,
+    jump: model.jump,
+    pass: model.pass,
+    serve: model.serve,
+    reception: model.reception,
+    setting: model.setting,
+    spike: model.spike,
+    stamina: model.stamina,
+    block: model.block,
+    backAttack: model.back_attack
+  })
+}
+
+export {
+  transformToObject as transformToPerformanceStats,
+  transformToAttributes as transformFromPerformanceStats
+}

package/src/data/transformers/player.ts

@@ -0,0 +1,109 @@
+import { PlayerAttributes, PlayerModel } from '../models'
+import { Player, Team } from '../../service'
+import { transformFromTrait, transformToAPITrait, transformToTrait } from './trait'
+import { transformFromRole, transformToRole } from './role'
+import { transformToPerformanceStats } from './performance-stats'
+import { transformToCountry } from './country'
+import { APIPlayer, APISetStatistics } from '../../routing'
+import { GeneralStat } from '../../service/player/stats'
+import { transformToAPIMatchSetStats } from './match-set-stats'
+
+function transformToAttributes (player: Player, team: Team): PlayerAttributes {
+  return {
+    player_id: player.id,
+    team_id: team.id,
+    country_id: player.country.id,
+    jersey_number: player.jerseyNumber,
+    first_name: player.name.first,
+    last_name: player.name.last,
+    traits: player.traits.map(transformFromTrait),
+    roles: player.roles.map(transformFromRole)
+  }
+}
+
+function transformToObject (model: PlayerModel): Player {
+  return new Player({
+    id: model.player_id,
+    name: {
+      first: model.first_name,
+      last: model.last_name
+    },
+    country: transformToCountry(model.country),
+    roles: model.roles.map(transformToRole),
+    traits: model.traits.map(transformToTrait),
+    jerseyNumber: model.jersey_number,
+    stats: transformToPerformanceStats(model.PerformanceStat),
+    team: model.team_id
+  })
+}
+
+function transformToAPIObject (model: PlayerModel): APIPlayer {
+  const generalStats = GeneralStat.getStats().map(stat => ({
+    name: stat,
+    value: GeneralStat.calculateScore(transformToPerformanceStats(model.PerformanceStat), stat)
+  }))
+  const gameStats = model.MatchSetStats.map(transformToAPIMatchSetStats)
+
+  gameStats.push(calculateMatchStats(gameStats))
+
+  return {
+    id: model.player_id,
+    name: {
+      first: model.first_name,
+      last: model.last_name
+    },
+    country: transformToCountry(model.country),
+    roles: model.roles.map(transformToRole),
+    traits: model.traits.map(transformToAPITrait),
+    jerseyNumber: model.jersey_number,
+    team: model.team_id,
+    generalStats,
+    gameStats
+  }
+}
+
+function calculateMatchStats (gameStats: APISetStatistics[]): APISetStatistics {
+  const emptyStats: APISetStatistics = {
+    playerId: gameStats[0].playerId,
+    attempts: 0,
+    contacts: 0,
+    ralliesPlayed: 0,
+    serve: { success: 0, error: 0 },
+    reception: { success: 0, error: 0 },
+    set: { success: 0, error: 0 },
+    attack: { success: 0, error: 0 },
+    block: { success: 0, error: 0 },
+    kills: 0,
+    killBlocks: 0,
+    ace: 0,
+    assists: 0,
+    order: gameStats.length
+  }
+
+  return gameStats.reduce((acc, current) => {
+    acc.attempts += current.attempts
+    acc.contacts += current.contacts
+    acc.ralliesPlayed += current.ralliesPlayed
+    acc.kills += current.kills
+    acc.killBlocks += current.killBlocks
+    acc.ace += current.ace
+    acc.assists += current.assists
+    acc.serve.success += current.serve.success
+    acc.serve.error += current.serve.error
+    acc.reception.success += current.reception.success
+    acc.reception.error += current.reception.error
+    acc.set.success += current.set.success
+    acc.set.error += current.set.error
+    acc.attack.success += current.attack.success
+    acc.attack.error += current.attack.error
+    acc.block.success += current.block.success
+    acc.block.error += current.block.error
+    return acc
+  }, emptyStats)
+}
+
+export {
+  transformToObject as transformToPlayer,
+  transformToAPIObject as transformToAPIPlayer,
+  transformToAttributes as transformFromPlayer
+}

package/src/data/transformers/rally-position.ts

@@ -0,0 +1,24 @@
+import { PlayerPosition, Rally } from '../../service'
+import { RallyPositionAttributes, RallyPositionModel } from '../models'
+import { transformFromCourtPosition, transformToCourtPosition } from './court-position'
+
+function transformToAttributes (playerPosition: PlayerPosition, side: 'Home' | 'Away', rally: Rally): RallyPositionAttributes {
+  return {
+    rally_id: rally.id,
+    side,
+    court_position: transformFromCourtPosition(playerPosition.position),
+    player_id: playerPosition.playerId
+  }
+}
+
+function transformToObject (model: RallyPositionModel): PlayerPosition {
+  return {
+    playerId: model.player_id,
+    position: transformToCourtPosition(model.court_position)
+  }
+}
+
+export {
+  transformToObject as transformToPlayerPosition,
+  transformToAttributes as transformFromPlayerPosition
+}

package/src/data/transformers/rally.ts

@@ -0,0 +1,139 @@
+import { RallyAttributes, RallyModel as RallyModel } from '../models/Rally'
+import {
+  Block,
+  EventType,
+  LiberoReplacement,
+  MatchSet,
+  Rally,
+  RallyEvent,
+  Reception,
+  Score,
+  Serve,
+  Set,
+  Spike,
+  Substitution
+} from '../../service'
+import { transformToTeam } from './team'
+import { transformFromPlayerPosition, transformToPlayerPosition } from './rally-position'
+import {
+  transformFromLiberoReplacement,
+  transformToAPILiberoReplacement,
+  transformToLiberoReplacement
+} from './libero-replacement'
+import { transformFromSubstitution, transformToAPISubstitution, transformToSubstitution } from './substitution'
+import { transformFromServe, transformToAPIServe, transformToServe } from './serve'
+import { transformFromReception, transformToAPIReception, transformToReception } from './reception'
+import { transformFromSet, transformToAPISet, transformToSet } from './set'
+import { transformFromSpike, transformToAPISpike, transformToSpike } from './spike'
+import { transformFromBlock, transformToAPIBlock, transformToBlock } from './block'
+import { transformFromScore, transformToAPIScore, transformToScore } from './score'
+import { RallyPositionAttributes } from '../models'
+import {
+  APIBlock,
+  APIEvent,
+  APILiberoReplacement,
+  APIRally,
+  APIReception,
+  APIScore,
+  APIServe,
+  APISet,
+  APISpike,
+  APISubstitution
+} from '../../routing'
+
+function transformToAttributes (rally: Rally, set: MatchSet): RallyAttributes {
+  const rallyPositions: RallyPositionAttributes[] = [
+    ...rally.awayPlayerPosition.map(pp => transformFromPlayerPosition(pp, 'Away', rally)),
+    ...rally.homePlayerPosition.map(pp => transformFromPlayerPosition(pp, 'Home', rally))
+  ]
+
+  const temp = {}
+
+  for (const p of rallyPositions) {
+    // @ts-ignore
+    if (temp[p.player_id] != null) {
+      throw new Error('DUPLICATE_KEY')
+    } else {
+      // @ts-ignore
+      temp[p.player_id] = p.rally_id
+    }
+  }
+
+  return {
+    rally_id: rally.id,
+    match_set_id: set.id,
+    order: rally.order,
+    serving_team: rally.servingTeam.id,
+    RallyPositions: rallyPositions,
+    LiberoReplacements: rally.events.filter(event => event.eventType === EventType.LIBERO_REPLACEMENT)
+      .map(event => transformFromLiberoReplacement(event as LiberoReplacement, rally)),
+    Substitutions: rally.events.filter(event => event.eventType === EventType.SUBSTITUTION)
+      .map(event => transformFromSubstitution(event as Substitution, rally)),
+    Serves: rally.events.filter(event => event.eventType === EventType.SERVE)
+      .map(event => transformFromServe(event as Serve, rally)),
+    Receptions: rally.events.filter(event => event.eventType === EventType.RECEPTION)
+      .map(event => transformFromReception(event as Reception, rally)),
+    Sets: rally.events.filter(event => event.eventType === EventType.SET)
+      .map(event => transformFromSet(event as Set, rally)),
+    Spikes: rally.events.filter(event => event.eventType === EventType.SPIKE)
+      .map(event => transformFromSpike(event as Spike, rally)),
+    Blocks: rally.events.filter(event => event.eventType === EventType.BLOCK)
+      .map(event => transformFromBlock(event as Block, rally)),
+    Scores: rally.events.filter(event => event.eventType === EventType.SCORE)
+      .map(event => transformFromScore(event as Score, rally))
+  }
+}
+
+function transformToObject (model: RallyModel): Rally {
+  const liberoReplacements: LiberoReplacement[] = model.LiberoReplacements.map(transformToLiberoReplacement)
+  const substitutions: Substitution[] = model.Substitutions.map(transformToSubstitution)
+  const serves: Serve[] = model.Serves.map(transformToServe)
+  const receptions: Reception[] = model.Receptions.map(transformToReception)
+  const sets: Set[] = model.Sets.map(transformToSet)
+  const spikes: Spike[] = model.Spikes.map(transformToSpike)
+  const blocks: Block[] = model.Blocks.map(transformToBlock)
+  const scores: Score[] = model.Scores.map(transformToScore)
+  const events: RallyEvent[] = [...liberoReplacements, ...substitutions, ...serves, ...receptions, ...sets, ...spikes, ...blocks, ...scores]
+    .sort((e1, e2) => e1.order - e2.order)
+
+  return new Rally({
+    id: model.rally_id,
+    order: model.order,
+    servingTeam: transformToTeam(model.serving_team_Team),
+    awayPlayerPosition: model.RallyPositions.filter(rp => rp.side === 'Away')
+      .map(transformToPlayerPosition),
+    homePlayerPosition: model.RallyPositions.filter(rp => rp.side === 'Home')
+      .map(transformToPlayerPosition),
+    events: events
+  })
+}
+
+function transformToAPIObject (model: RallyModel): APIRally {
+  const liberoReplacements: APILiberoReplacement[] = model.LiberoReplacements.map(transformToAPILiberoReplacement)
+  const substitutions: APISubstitution[] = model.Substitutions.map(transformToAPISubstitution)
+  const serves: APIServe[] = model.Serves.map(transformToAPIServe)
+  const receptions: APIReception[] = model.Receptions.map(transformToAPIReception)
+  const sets: APISet[] = model.Sets.map(transformToAPISet)
+  const spikes: APISpike[] = model.Spikes.map(transformToAPISpike)
+  const blocks: APIBlock[] = model.Blocks.map(transformToAPIBlock)
+  const scores: APIScore[] = model.Scores.map(transformToAPIScore)
+  const events: APIEvent[] = [...liberoReplacements, ...substitutions, ...serves, ...receptions, ...sets, ...spikes, ...blocks, ...scores]
+    .sort((e1, e2) => e1.order - e2.order)
+
+  return {
+    id: model.rally_id,
+    order: model.order,
+    servingTeamId: model.serving_team,
+    awayPlayerPosition: model.RallyPositions.filter(rp => rp.side === 'Away')
+      .map(transformToPlayerPosition),
+    homePlayerPosition: model.RallyPositions.filter(rp => rp.side === 'Home')
+      .map(transformToPlayerPosition),
+    events: events
+  }
+}
+
+export {
+  transformToObject as transformToRally,
+  transformToAPIObject as transformToAPIRally,
+  transformToAttributes as transformFromRally
+}

package/src/data/transformers/reception.ts

@@ -0,0 +1,98 @@
+import { Rally, Reception, ReceptionFailure, ReceptionType } from '../../service'
+import { ReceptionAttributes, ReceptionModel } from '../models'
+import { transformFromEventType, transformToEventType } from './event-type'
+import { transformFromCourtTarget, transformToCourtTarget } from './court-target'
+import { transformToPlayer } from './player'
+import { APIReception } from '../../routing'
+
+type receptionType = 'DIG' | 'OVERHAND' | 'ONE_HAND' | 'OTHER_BODY_PART'
+type receptionFailure = 'NO_FAILURE' | 'FAULT' | 'MISS' | 'OUT_OF_BOUNDS' | 'BAD_PASS'
+
+function transformToReceptionFailure (failure: ReceptionFailure): receptionFailure {
+  switch (failure) {
+    case ReceptionFailure.NO_FAILURE:
+      return 'NO_FAILURE'
+    case ReceptionFailure.FAULT:
+      return 'FAULT'
+    case ReceptionFailure.MISS:
+      return 'MISS'
+    case ReceptionFailure.OUT_OF_BOUNDS:
+      return 'OUT_OF_BOUNDS'
+    case ReceptionFailure.BAD_PASS:
+      return 'BAD_PASS'
+    default:
+      throw new Error('UNKNOWN_ROLE')
+  }
+}
+
+function transformFromReceptionFailure (failure: receptionFailure): ReceptionFailure {
+  return ReceptionFailure[failure]
+}
+
+function transformToReceptionType (type: ReceptionType): receptionType {
+  switch (type) {
+    case ReceptionType.DIG:
+      return 'DIG'
+    case ReceptionType.OVERHAND:
+      return 'OVERHAND'
+    case ReceptionType.ONE_HAND:
+      return 'ONE_HAND'
+    case ReceptionType.OTHER_BODY_PART:
+      return 'OTHER_BODY_PART'
+    default:
+      throw new Error('UNKNOWN_ROLE')
+  }
+}
+
+function transformFromReceptionType (type: receptionType): ReceptionType {
+  return ReceptionType[type]
+}
+
+function transformToAttributes (event: Reception, rally: Rally): ReceptionAttributes {
+  return {
+    event_id: event.id,
+    player_id: event.player.id,
+    rally_id: rally.id,
+    order: event.order,
+    modifier: event.modifier,
+    score: event.score,
+    target: transformFromCourtTarget(event.target),
+    failure: transformToReceptionFailure(event.failure),
+    type: transformToReceptionType(event.type),
+    event_type: transformFromEventType(event.eventType)
+  }
+}
+
+function transformToObject (event: ReceptionModel): Reception {
+  return new Reception({
+    id: event.event_id,
+    eventType: transformToEventType(event.event_type),
+    failure: transformFromReceptionFailure(event.failure),
+    type: transformFromReceptionType(event.type),
+    player: transformToPlayer(event.player),
+    target: transformToCourtTarget(event.target),
+    modifier: event.modifier,
+    order: event.order,
+    score: event.score
+  })
+}
+
+function transformToAPIObject (event: ReceptionModel): APIReception {
+  return {
+    id: event.event_id,
+    eventType: transformToEventType(event.event_type),
+    failure: transformFromReceptionFailure(event.failure),
+    type: transformFromReceptionType(event.type),
+    playerId: event.player_id,
+    target: transformToCourtTarget(event.target),
+    modifier: event.modifier,
+    order: event.order,
+    score: event.score
+  }
+}
+
+export {
+  transformToObject as transformToReception,
+  transformToAPIObject as transformToAPIReception,
+  transformToAttributes as transformFromReception
+}

package/src/data/transformers/role.ts

@@ -0,0 +1,31 @@
+import { Role } from '../../service'
+
+type role = 'SETTER' | 'LIBERO' | 'OUTSIDE_HITTER' | 'OPPOSITE_HITTER' | 'MIDDLE_BLOCKER' | 'DEFENSIVE_SPECIALIST'
+
+function transformToType (role: Role): role {
+  switch (role) {
+    case Role.SETTER:
+      return 'SETTER'
+    case Role.DEFENSIVE_SPECIALIST:
+      return 'DEFENSIVE_SPECIALIST'
+    case Role.LIBERO:
+      return 'LIBERO'
+    case Role.MIDDLE_BLOCKER:
+      return 'MIDDLE_BLOCKER'
+    case Role.OUTSIDE_HITTER:
+      return 'OUTSIDE_HITTER'
+    case Role.OPPOSITE_HITTER:
+      return 'OPPOSITE_HITTER'
+    default:
+      throw new Error('UNKNOWN_ROLE')
+  }
+}
+
+function transformFromType (role: role): Role {
+  return Role[role]
+}
+
+export {
+  transformToType as transformFromRole,
+  transformFromType as transformToRole
+}

package/src/data/transformers/score.ts

@@ -0,0 +1,43 @@
+import { Rally, Score } from '../../service'
+import { ScoreAttributes, ScoreModel } from '../models'
+import { transformFromEventType, transformToEventType } from './event-type'
+import { transformToPlayer } from './player'
+import { transformToTeam } from './team'
+import { APIScore } from '../../routing'
+
+function transformToAttributes (event: Score, rally: Rally): ScoreAttributes {
+  return {
+    player_id: event.player.id,
+    event_id: event.id,
+    order: event.order,
+    event_type: transformFromEventType(event.eventType),
+    rally_id: rally.id,
+    team_id: event.team.id
+  }
+}
+
+function transformToObject (event: ScoreModel): Score {
+  return new Score({
+    id: event.event_id,
+    player: transformToPlayer(event.player),
+    order: event.order,
+    eventType: transformToEventType(event.event_type),
+    team: transformToTeam(event.team)
+  })
+}
+
+function transformToAPIObject (event: ScoreModel): APIScore {
+  return {
+    id: event.event_id,
+    eventType: transformToEventType(event.event_type),
+    playerId: event.player_id,
+    order: event.order,
+    teamId: event.team_id
+  }
+}
+
+export {
+  transformToObject as transformToScore,
+  transformToAPIObject as transformToAPIScore,
+  transformToAttributes as transformFromScore
+}

package/src/data/transformers/season.ts

@@ -0,0 +1,42 @@
+import { SeasonAttributes, SeasonModel } from '../models'
+import { transformToAPITeam, transformToTeam } from './team'
+import { League, Season } from '../../service/league'
+import { transformToAPIMatch, transformToMatch } from './match'
+import { APISeason } from '../../routing'
+import { transformToLeague } from './league'
+
+function transformToAttributes (season: Season, league: League): SeasonAttributes {
+  return {
+    season_id: season.id,
+    iteration: season.iteration,
+    league_id: league.id
+  }
+}
+
+function transformToObject (model: SeasonModel): Season {
+  return new Season({
+    id: model.season_id,
+    matches: model.Matches != null ? model.Matches.map(transformToMatch) : [],
+    iteration: model.iteration,
+    teams: model.seasonTeams != null ? model.seasonTeams.map(transformToTeam) : [],
+  })
+}
+
+function transformToAPIObject (model: SeasonModel): APISeason {
+  const season = transformToObject(model)
+
+  return {
+    id: model.season_id,
+    matches: model.Matches != null ? model.Matches.map(transformToAPIMatch) : [],
+    iteration: model.iteration,
+    teams: model.seasonTeams != null ? model.seasonTeams.map(transformToAPITeam) : [],
+    league: transformToLeague(model.league),
+    standings: season.standings
+  }
+}
+
+export {
+  transformToObject as transformToSeason,
+  transformToAPIObject as transformToAPISeason,
+  transformToAttributes as transformFromSeason
+}

package/src/data/transformers/serve.ts

@@ -0,0 +1,100 @@
+import { Rally, Serve, ServeFailure, ServeType } from '../../service'
+import { ServeAttributes, ServeModel } from '../models'
+import { transformFromEventType, transformToEventType } from './event-type'
+import { transformFromCourtTarget, transformToCourtTarget } from './court-target'
+import { transformToPlayer } from './player'
+import { APIServe } from '../../routing'
+
+type serveFailure = 'NO_FAILURE' | 'FAULT' | 'MISS' | 'NET' | 'OUT_OF_BOUNDS'
+type serveType = 'UNDERHAND' | 'OVERHAND_TOPSPIN' | 'OVERHAND_FLOAT' | 'JUMP_TOPSPIN' | 'JUMP_FLOAT'
+
+function transformToServeFailure (failure: ServeFailure): serveFailure {
+  switch (failure) {
+    case ServeFailure.NO_FAILURE:
+      return 'NO_FAILURE'
+    case ServeFailure.FAULT:
+      return 'FAULT'
+    case ServeFailure.MISS:
+      return 'MISS'
+    case ServeFailure.OUT_OF_BOUNDS:
+      return 'OUT_OF_BOUNDS'
+    case ServeFailure.NET:
+      return 'NET'
+    default:
+      throw new Error('UNKNOWN_ROLE')
+  }
+}
+
+function transformFromServeFailure (failure: serveFailure): ServeFailure {
+  return ServeFailure[failure]
+}
+
+function transformToServeType (type: ServeType): serveType {
+  switch (type) {
+    case ServeType.UNDERHAND:
+      return 'UNDERHAND'
+    case ServeType.OVERHAND_TOPSPIN:
+      return 'OVERHAND_TOPSPIN'
+    case ServeType.OVERHAND_FLOAT:
+      return 'OVERHAND_FLOAT'
+    case ServeType.JUMP_TOPSPIN:
+      return 'JUMP_TOPSPIN'
+    case ServeType.JUMP_FLOAT:
+      return 'JUMP_FLOAT'
+    default:
+      throw new Error('UNKNOWN_ROLE')
+  }
+}
+
+function transformFromServeType (type: serveType): ServeType {
+  return ServeType[type]
+}
+
+function transformToAttributes (event: Serve, rally: Rally): ServeAttributes {
+  return {
+    event_id: event.id,
+    player_id: event.player.id,
+    rally_id: rally.id,
+    order: event.order,
+    modifier: event.modifier,
+    score: event.score,
+    target: transformFromCourtTarget(event.target),
+    failure: transformToServeFailure(event.failure),
+    type: transformToServeType(event.type),
+    event_type: transformFromEventType(event.eventType)
+  }
+}
+
+function transformToObject (serve: ServeModel): Serve {
+  return new Serve({
+    id: serve.event_id,
+    eventType: transformToEventType(serve.event_type),
+    failure: transformFromServeFailure(serve.failure),
+    type: transformFromServeType(serve.type),
+    player: transformToPlayer(serve.player),
+    target: transformToCourtTarget(serve.target),
+    modifier: serve.modifier,
+    order: serve.order,
+    score: serve.score
+  })
+}
+
+function transformToAPIObject (event: ServeModel): APIServe {
+  return {
+    id: event.event_id,
+    eventType: transformToEventType(event.event_type),
+    failure: transformFromServeFailure(event.failure),
+    type: transformFromServeType(event.type),
+    playerId: event.player_id,
+    target: transformToCourtTarget(event.target),
+    modifier: event.modifier,
+    order: event.order,
+    score: event.score
+  }
+}
+
+export {
+  transformToObject as transformToServe,
+  transformToAPIObject as transformToAPIServe,
+  transformToAttributes as transformFromServe
+}