fifadat 0.0.1

data/lib/fifadat/pp/build_match.rb

@@ -0,0 +1,105 @@
+
+
+
+def _build_match( m )   ## use _fill/build_match_basics() or such ???
+    rec = {}
+
+    ## 0 =>   FINISHED/complete (OK)
+       ## 1 =>   SCHEDULED/not yet played
+       status = m['MatchStatus']
+       timed  = m['TimeDefined']
+
+       if status == 1 && timed    ## note: use TIMED (instead of SCHEDULED)
+          rec[:status] = 'TIMED'
+       else
+          rec[:status] = MATCH_STATUS[ status ] || "#{status}-???"
+       end
+
+
+
+       rec[:stage]  = desc( m['StageName'] )
+
+       ## check optional  group, matchday, (match) num
+       ##    note - matchday is a string!! (check if always a number)
+       ##      ## convert to int if str - why? why not??
+       group = desc( m['GroupName'] )
+       rec[:group]  = group   if group
+
+       matchday  = m['MatchDay']
+       rec[:matchday]  = matchday.to_i(10)  if matchday
+
+       num  = m['MatchNumber']
+       rec[:num]  = num   if num
+
+
+       dateTime       = parse_date_utc( m['Date'] )
+       localDateTime  = parse_date_utc( m['LocalDate'] )
+
+       if timed
+         ##  pass along as is for now - why? why not
+         ##   note - Date is date_utc and
+         ##      LocalDate is date_local (also in utc BUT different HH:MM or possible day)
+         ## note - also in utc, that is, timezone is Z (not +03:00 or such!!!)
+
+         ## note - use datetime  - why? why not?
+         ##
+         ## note - cut-off/remove seconds
+         rec[:datetime_utc]   = dateTime.strftime( '%Y-%m-%dT%H:%MZ' )
+
+         ## note - use  20:30 UTC+1  or 20:30 UTC-3  for timezone format for now
+         rec[:datetime_local] = _fmt_date_local( dateTime, localDateTime )
+       else
+         rec[:date]      = dateTime.strftime( '%Y-%m-%d' )
+       end
+
+
+
+       if m['HomeTeam'] && m['AwayTeam']   ## assume match reports
+         team1 = build_team( m['HomeTeam'] )
+         team2 = build_team( m['AwayTeam'] )
+          ##  use full team details here (via lookup)
+         ##         when report (mode) - why? why not?
+         rec[:team1] = team1[:name]
+         rec[:team2] = team2[:name]
+       else
+         team1 =  build_team( m['Home'] )
+         team2 =  build_team( m['Away'] )
+         rec[:team1] = team1[:name]
+         rec[:team2] = team2[:name]
+       end
+
+
+
+  #####
+  #  handle score
+  ## m = (full) match hash incl.  IdMatch, etc.
+  ##  returns string e.g.  4-4  or 4-3 a.e.t etc
+
+     score = _parse_score( m )
+     rec[:score] = score      unless score.empty?
+
+
+       ## check - never in use?
+       rec[:home]  = true    if m['IsHome']
+
+
+       ## add country to stadium too - why? why not?
+       stadium = build_stadium( m['Stadium'] )
+
+
+       if m['HomeTeam'] && m['AwayTeam']   ## assume match reports
+         rec[:stadium] = {  name: stadium[:name],
+                            city: stadium[:city],
+                            street: stadium[:street],
+                            country: stadium[:country] }
+       else
+          rec[:stadium] = {  name:    stadium[:name],
+                              city:    stadium[:city] }
+       end
+
+       attendance = m['Attendance']
+       rec[:attendance] = attendance.to_i(10)   if attendance
+
+
+      rec
+end

data/lib/fifadat/pp/build_report.rb

@@ -0,0 +1,135 @@
+
+
+def _build_report_score( live, timeline=nil )
+
+    _scores = _build_score_from_goals( live )
+
+
+    score = nil
+
+     case live['ResultType']
+     when 1,4
+         ## 1 => 'REGULAR',
+         ## 4 => 'REGULAR/AGG',  ##  aggregate (1st/2nd leg) - regular
+        ## add ht
+        ##  assert ft match
+        score      = {  ht: _scores[:ht][:score],
+                         ft: _scores[:ft][:score]
+                      }
+     when 3,5,8
+       score       = {   ht: _scores[:ht][:score],
+                         ft: _scores[:ft][:score],
+                         et: _scores[:et][:score],
+                      }
+     when 2
+        ##  todo/fix - pull in timeline check too to check
+        ##     if any events recorded for extra time!!
+        score      = {   ht: _scores[:ht][:score],
+                         ft: _scores[:ft][:score],
+                      }
+
+        ## note - only incl. extra-time (et) if a goal scored in extra time
+        score[:et] = _scores[:et][:score]   unless _scores[:et][:minutes].empty?
+     end
+
+     score
+end
+
+
+
+def _build_report( live, timeline=nil )
+       rec = {}
+
+
+####
+##  add goals
+   players = Players.new
+   players.add( live['HomeTeam']['Players'] )
+   players.add( live['AwayTeam']['Players'] )
+
+   rec[:goals1] = build_goals( live['HomeTeam']['Goals'], players: players )
+   rec[:goals2] = build_goals( live['AwayTeam']['Goals'], players: players )
+
+
+      ##########
+      ##   add penalty kicks / penalties
+      if live['ResultType'] == 2   ## aet, win on pens
+         if timeline.nil?
+            ##
+            team1_code = live['HomeTeam']['Abbreviation']
+            team2_code = live['AwayTeam']['Abbreviation']
+            puts "!! ERROR - no timeline for match #{team1_code} v #{team2_code} with win on penalties!!"
+            exit 1
+         else
+            ### get timeline with penalty shoot-out details
+            ##     note - requires team1/2_ids!!!
+            team1_id = live['HomeTeam']['IdTeam']
+            team2_id = live['AwayTeam']['IdTeam']
+
+            pens = build_penalties( timeline['Event'],
+                                     players: players,
+                                     team1_id: team1_id,
+                                     team2_id: team2_id )
+            pp pens
+
+            rec[:penalties] = pens
+         end
+      end
+
+
+##
+##  add players by team1/team2
+   players1 = Players.new
+   players1.add( live['HomeTeam']['Players'] )
+
+   players2 = Players.new
+   players2.add( live['AwayTeam']['Players'] )
+
+
+   rec[:formation1] = live['HomeTeam']['Tactics']   ## e.g. "Tactics": "3-1-4-2"
+   rec[:lineup1] = players1.lineup   ## starter XI
+   rec[:bench1]  = players1.bench    ## substitutes
+
+   rec[:formation2] = live['AwayTeam']['Tactics']
+   rec[:lineup2] = players2.lineup
+   rec[:bench2]  = players2.bench
+
+
+#####
+## add bookings (yellow/red/red-yellow cards)
+   players1.add_bookings( live['HomeTeam']['Bookings'])
+   players2.add_bookings( live['AwayTeam']['Bookings'])
+
+
+   yellow1    = players1.yellowcards
+   red1       = players1.redcards
+   yellowred1 = players1.yellowredcards
+   rec[:yellow1]     = yellow1    unless yellow1.empty?
+   rec[:red1]        = red1       unless red1.empty?
+   rec[:yellowred1]  = yellowred1 unless yellowred1.empty?
+
+   yellow2    = players2.yellowcards
+   red2       = players2.redcards
+   yellowred2 = players2.yellowredcards
+   rec[:yellow2]     = yellow2    unless yellow2.empty?
+   rec[:red2]        = red2       unless red2.empty?
+   rec[:yellowred2]  = yellowred2 unless yellowred2.empty?
+
+
+
+## add substitutions (off/on - in/out)
+   rec[:subs1] = build_subs( live['HomeTeam']['Substitutions'], players: players1 )
+   rec[:subs2] = build_subs( live['AwayTeam']['Substitutions'], players: players2 )
+
+
+## add referees
+   officials = build_officials( live['Officials'], id: false )
+
+    if officials.empty?
+      ## puts "!! WARN no refs / officials found"
+    else
+         rec[:referees] = officials
+    end
+
+    rec
+end

data/lib/fifadat/pp/convert-reports.rb

@@ -0,0 +1,114 @@
+
+
+##
+##   read & build match report
+
+## use mk/build_report_basename - why? why not?
+##     fix-fix-fix - change to _match_basename !!!
+##        use by (match)report and (match)timeline !!!
+def _report_basename( m )
+      ### get match (live) details
+      team1_code = m['Home']['Abbreviation']
+      team2_code = m['Away']['Abbreviation']
+      localDateTime  = parse_date_utc( m['LocalDate'] )
+
+      ##  e.g.  2020-06-24_RAP-AUS__54545454
+      basename = String.new
+      basename += localDateTime.strftime('%Y-%m-%d')    ##   i) date
+      basename += "_#{team1_code}-#{team2_code}"        ##  ii) team1 v team2
+
+      basename
+end
+
+
+
+def _read_timeline( m, timeline_dir: )
+      return nil     if m['Home'].nil? || m['Away'].nil?
+
+      basename = _report_basename( m )
+      basename += "__#{m['IdMatch']}"
+
+      path = "#{timeline_dir}/#{basename}.json"
+
+      ## note - skip if no match report available!!!
+      if File.file?( path )
+         timeline = read_json_v2( path )
+         timeline
+      else
+         nil
+      end
+end
+
+def _read_report( m, report_dir: )
+      return nil     if m['Home'].nil? || m['Away'].nil?
+
+      ##  e.g.  2020-06-24_RAP-AUS__54545454
+      #   note - add match id for "raw" match reports!!!
+      basename = _report_basename( m )
+      basename += "__#{m['IdMatch']}"
+
+      ## #{indir}/#{slug}/matches/#{season.to_path}
+      path = "#{report_dir}/#{basename}.json"
+
+      ## note - skip if no match report available!!!
+      if File.file?( path )
+         live = read_json_v2( path )
+         live
+      else
+         nil
+      end
+end
+
+
+
+
+
+
+def convert_reports( slug:, season:,
+                         indir: '.',
+                         outdir: './tmp' )
+
+   season = Season(season)
+
+   data =  read_json_v2( "#{indir}/#{slug}/#{season.to_path}_matches.json" )
+   matches = data['Results']  ## only use results (match) array
+   puts "  #{matches.size} match(es) in season #{season}"
+
+
+   report_dir = "#{indir}/#{slug}/matches/#{season.to_path}"
+   timeline_dir = "#{indir}/#{slug}/timelines/#{season.to_path}"
+
+
+
+   matches.each_with_index do |m, i|
+      live     = _read_report( m, report_dir: report_dir )
+
+      ## no report found; continue
+      next  if live.nil?
+
+      ## check for optional timeline
+      timeline = _read_timeline( m, timeline_dir: timeline_dir )
+
+      rec = {
+               meta: {
+                  name: desc(live['SeasonName']),
+                  slug: slug,
+                  season: season.to_s,
+                  generated: Time.now.to_s,
+               }
+            }.merge( _build_match( live ),
+                     _build_report( live, timeline ))
+
+      ## try  update of score via goals from report
+      score_more =  _build_report_score( live, timeline )
+      if score_more
+           rec[:score] = rec[:score].merge( score_more )
+      end
+
+
+      ## build basename e.g  2026-07-15_ARG-ENG
+      basename = _report_basename( m )
+      outpath = "#{outdir}/#{season.to_path}/#{slug}/#{basename}.json"
+      write_json( outpath, rec )
+   end
+end

data/lib/fifadat/pp/convert.rb

@@ -0,0 +1,163 @@
+
+
+
+def convert( slug:, season:,
+                indir: '.',
+                outdir: './tmp' )
+
+    season = Season(season)
+
+    ## fix - change data to top or ??? - why? why not?
+    data = {}
+
+    ## add slug & seasons (add name to be done!!)
+    data[:meta] = { slug:      slug,
+                    season:    season.to_s,
+                    generated: Time.now.to_s,
+                  }
+
+
+   matches =  read_json_v2( "#{indir}/#{slug}/#{season.to_path}_matches.json" )
+   matches = matches['Results']  ## only use results (match) array
+
+   ## pp matches
+   puts "  #{matches.size} match(es) in season #{season}"
+
+
+  ## read in stages
+  ##   incl.  SequenceOrder, StageLevel (optional)
+  stages = Stages.read( "#{indir}/#{slug}/misc/#{season.to_path}_stages.json" )
+
+
+  stages.add_matches( matches )
+  data[:stages] = stages.as_json
+
+
+   teams = Teams.new
+   teams.add_matches( matches )
+   data[:teams] = teams.as_json
+
+
+   stadiums = Stadiums.new
+   stadiums.add_matches( matches )
+   data[:stadiums] = stadiums.as_json
+
+
+   ## for match-by-match live reports
+   report_dir = "#{indir}/#{slug}/matches/#{season.to_path}"
+   timeline_dir = "#{indir}/#{slug}/timelines/#{season.to_path}"
+
+
+   recs = []
+   matches.each_with_index do |m, i|
+
+       ## add/track id too - why? why not?
+       ##  rec[:id]  = m['IdMatch']
+
+
+        ## add/fill-up match basic
+       rec = _build_match( m )
+
+
+   ### get match (live) details
+   ###
+   ##   check if match report exits
+   ##    optional for now!!
+
+      live = _read_report( m, report_dir: report_dir )
+
+
+      ## if live.nil?
+      ##   puts "warn no match report for #{_report_basename(m)}"
+      ## end
+
+   if live
+      ## check for timeline
+      timeline = _read_timeline( m, timeline_dir: timeline_dir )
+      ## reuse generated output from report
+        report = _build_report( live, timeline )
+
+        ## try  update of score via goals from (match) report
+        score_more =  _build_report_score( live, timeline )
+        if score_more
+           rec[:score] = rec[:score].merge( score_more )
+        end
+
+
+
+        goals1 = report[:goals1]
+        goals2 = report[:goals2]
+
+
+       if goals1.empty? && goals2.empty?
+          ## skip if no goals
+       else
+         rec[:goals1] = goals1
+         rec[:goals2] = goals2
+
+
+
+       end
+
+
+       #########
+       ##  add penalties
+         penalties = report[:penalties]
+          rec[:penalties] = penalties   if penalties && !penalties.empty?
+
+
+      sentoff1 =  (report[:red1]||[]) + (report[:yellowred1]||[])
+      sentoff2 =  (report[:red2]||[]) + (report[:yellowred2]||[])
+
+      ## sort by minute
+      sentoff1 = sentoff1.sort { |l,r|  l[:minute] <=> r[:minute] }
+      sentoff2 = sentoff2.sort { |l,r|  l[:minute] <=> r[:minute] }
+
+     rec[:sentoff1] = sentoff1    unless sentoff1.empty?
+     rec[:sentoff2] = sentoff2    unless sentoff2.empty?
+ end
+
+
+
+=begin
+   "Officials":
+     [{"IdCountry": "BRA",
+       "OfficialId": "361561",
+       "NameShort": [{"Locale": "en-GB", "Description": "Wilton SAMPAIO"}],
+       "Name": [{"Locale": "en-GB", "Description": "Wilton SAMPAIO"}],
+       "OfficialType": 1,
+       "TypeLocalized": [{"Locale": "en-GB", "Description": "Referee"}]},
+      {"IdCountry": "PAR",
+       "OfficialId": "416159",
+       "NameShort":
+        [{"Locale": "en-GB", "Description": "Juan Gabriel BENITEZ"}],
+       "Name": [{"Locale": "en-GB", "Description": "Juan Gabriel Benítez"}],
+       "OfficialType": 4,
+       "TypeLocalized":
+        [{"Locale": "en-GB", "Description": "Fourth official"}]}],
+=end
+
+###
+##  add referees
+    officials = build_officials( m['Officials'], id: false )
+
+    if officials.empty?
+       ## puts "!! WARN no refs / officials found"
+    else
+         rec[:referees] = officials
+    end
+
+
+
+
+      recs << rec
+   end
+   data[:matches] = recs
+
+
+    outpath =  "#{outdir}/#{season.to_path}/#{slug}.json"
+    write_json( outpath, data)
+    puts "  written to >#{outpath}<"
+
+    true
+end

data/lib/fifadat/pp/goals-calc_score.rb

@@ -0,0 +1,58 @@
+
+
+def _build_score_from_goals( m )
+   ##
+   ## 5 periods - 3 (1ST_HALF), 5 (2ND_HALF),
+   ##             7 (EXTRA_TIME_1ST_HALF), 9 (EXTRA_TIME_2ND_HALF),
+   ##             11 (PENALTY_SHOOTOUT) possibly
+   ##
+   goals = {
+      count: 0,
+      score: [0,0],
+      ht:   { score: [0,0], minutes: [] },
+      ft:   { score: [0,0], minutes: [] },
+      et:   { score: [0,0], minutes: [] },
+      p:    { score: [0,0], minutes: [] },
+   }
+
+   ## note - quick fix
+   ##            add  period 2  for USA v Belgium (PKO) - worldcup
+
+   ## note - i is 0|1  -  array index for team
+   [m['HomeTeam']['Goals'],
+    m['AwayTeam']['Goals']].each_with_index do |recs,i|
+      recs.each do |h|
+
+        h = errata_autofix_goal( h )
+
+        period = h['Period']
+        ## include penalty shootout (11) - why? why not?
+        assert(  [3,5,7,9,11].include?(period),
+                  "goal in period 3/5/7/9/11 expected; got #{h.pretty_inspect} in match #{m.pretty_inspect}" )
+
+        minute = h['Minute']
+        key =  case period
+               when 3    then  :ht
+               when 5    then  :ft
+               when 7, 9 then  :et
+               when 11   then  :p
+               else
+                raise ArgumentError,
+                  "goal in period 3/5/7/9/11 expected; got #{h.pretty_inspect}"
+               end
+
+        goals[:count] += 1
+        goals[:score][i] += 1   unless key == :p
+        goals[key][:score][i] += 1
+      end
+   end
+
+   ## use/calc cummulative score  (BUT not for penalties)
+   goals[:ft][:score][0] += goals[:ht][:score][0]
+   goals[:ft][:score][1] += goals[:ht][:score][1]
+
+   goals[:et][:score][0] += goals[:ft][:score][0]
+   goals[:et][:score][1] += goals[:ft][:score][1]
+
+   goals
+end

data/lib/fifadat/pp/goals.rb

@@ -0,0 +1,89 @@
+
+
+
+
+def build_goal( h, players: )
+
+    ## split into minute
+    ##  and offset (stoppage/injury time)
+    ##  e.g. 90'+11'
+
+     h = errata_autofix_goal( h )
+
+     minute_str = h['Minute']
+
+     period = h['Period']
+
+     ##   note - penalty shootout gets excluded upstream!!
+     ##  include penalty shootout (11) - why? why not?
+     ## assert(  [3,5,7,9].include?(period),
+     ##             "goal in period 3/5/7/9 expected; got #{h.pretty_inspect}" )
+
+    ##  quick fix:
+    ## check for weird minute 0 e.g.
+    ##   Germany-Austria 1934
+    if minute_str == "0'"
+       h['Minute'] = "1'"
+    end
+
+    if minute_str.nil? || minute_str.empty?
+           puts "!! minute in goal is nil or empty:"
+           pp h
+           exit 1
+    end
+
+    minute = _build_minute( h )
+
+
+    rec = {}
+
+      idPlayer = h['IdPlayer']
+
+      if idPlayer.nil?
+         puts "!! no idPlayer for goal!"
+         pp h
+          ##exit 1
+          ## use 'N.N.'
+
+          rec[ :name ] = 'N.N.'
+
+      else
+        player = players.find!( idPlayer )
+        rec[ :name ] = player[ :name ]
+      end
+
+     rec[ :minute] = minute
+
+
+      ## check for goal type (og) or (p)
+      ##  1 -  "penalty"
+      ##  2 -  "regular"
+      ##  3 -  "own goal"
+
+      type =  h['Type']
+      rec[ :pen ] = true  if type == 1
+      rec[ :og ]  = true  if type == 3
+
+      rec
+end
+
+
+
+
+def build_goals( recs, players:,  penalties: false )
+
+    ## note - filter out penalties (from shoot-out)!!
+    ##    min > 120  (e.g. 121, etc.)
+    ##  note - use period (more reliable)
+    ##   period 11 is PENALTY_SHOOTOUT!!
+    if penalties == false
+       recs = recs.select { |rec| rec['Period'] != 11 }
+    end
+
+
+    recs = recs.map  { |h| build_goal( h, players: players ) }
+
+    ## note - sort by minutes; goals may not be sorted
+    recs = recs.sort { |l,r| l[:minute] <=> r[:minute] }
+    recs
+end

data/lib/fifadat/pp/helper-date.rb

@@ -0,0 +1,13 @@
+
+
+def _fmt_date_local(  date_utc, date_local )
+
+  ## note:  returns Rational (e.g. 3/1 or 1/4 etc.) use to_f/to_i to convert
+  diff_in_hours = ((date_local - date_utc) * 24).to_f
+  diff_in_days  =  date_local.jd - date_utc.jd
+  ## pp [diff_in_hours, diff_in_days]
+
+
+  ## use   20:30 UTC+1  or 20:30 UTC-3
+  "#{date_local.strftime( '%Y-%m-%d %H:%M' )} UTC%+d" % diff_in_hours
+end