volleyballsimtypes 0.0.7 → 0.0.8

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

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

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

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

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

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

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

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

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

@@ -1,100 +0,0 @@
-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
-}