fifadat-convert 0.0.1 → 0.1.0

data/lib/fifadat/{convert/officials.rb → models/official.rb}

@@ -1,5 +1,24 @@
 
 =begin
+
+=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"}]}],
+
+
   "Officials":
      [{"IdCountry": "URU",
        "OfficialId": "61038",
@@ -25,13 +44,16 @@
 =end
 
 
+class Official
+
   TYPE_OFFICIAL = {
     1 => 'Referee',
     2 => 'Assistant Referee 1',
     3 => 'Assistant Referee 2',
   }
 
-def build_official( h, id: )
+
+def self.build( h )
     name = desc( h['Name'] )
 
     ## fix - use norm_official
@@ -40,29 +62,23 @@ def build_official( h, id: )
     idCountry = h['IdCountry']
     type      = h['OfficialType']
 
-
     assert( is_alpha?(name), "official name alpha expected; got #{pp_alpha(name)}" )
 
-
-
     assert( [1,2,3,4,5,6,7,8,9,10].include?( type ), "official type 1/2/3/4/5/6/7/8/9/10 expected; got #{type}" )
 
-    rec = {}
-    rec[:id] = h['OfficialId']   if id
-
-    rec.merge!( name:      name,
-                country:   idCountry,
-                type:      type )
-
-    rec
-   end
+    rec = {   id:  h['OfficialId'],
+              name:      name,
+              country:   idCountry,
+              type:      TYPE_OFFICIAL[type]  ## change type to literal string
+           }
 
+    new(**rec)
+end
 
-def build_officials( recs, id: false )  ## use referees?
-    recs = recs.map  { |h| build_official( h, id: id ) }
+def self._build_ary( recs )  ## use referees?
 
     ## skip fourth official (4) for now
-    recs = recs.select { |h|  [1,2,3].include?( h[:type] ) }
+    recs = recs.select { |h|  [1,2,3].include?( h['OfficialType'] ) }
 
     ## sort by type 1/2/3
     ##  1 - referee
@@ -75,12 +91,34 @@ def build_officials( recs, id: false )  ## use referees?
     ##  8 - assistant var
     ##  9 - support var
     ## 10 - reserve assistant referee
+    recs = recs.sort { |l,r|  l['OfficialType'] <=> r['OfficialType'] }
 
 
-    recs = recs.sort { |l,r|  l[:type] <=> r[:type] }
-
-    ## change type to literal string
-    recs = recs.map { |h| h[:type]=TYPE_OFFICIAL[h[:type]]; h }
+    recs = recs.map  { |h| build( h ) }
 
     recs
 end
+
+attr_reader :id, :name, :country, :type
+
+def initialize( id:, name:, country:, type:)
+  @id   = id
+  @name    = name
+  @country = country
+  @type    = type
+end
+
+   def as_json(*)
+      h = {
+            'name'      => name,
+            'country'   => country,
+            'type'      => type,
+          }
+      h
+   end
+
+
+
+
+
+end # class Official

data/lib/fifadat/{convert/penalties.rb → models/penalty.rb}

@@ -17,13 +17,14 @@
      [{"Locale": "en-GB",
        "Description":
         "David BATTY (England) misses from the penalty spot!"}]}],
- "Properties": {},
- "IsUpdateable": null}
+   }
 =end
 
 
-def build_penalty( h, players:,
-                      team1_id:, team2_id: )
+class Penalty
+
+def self.build( h, players:,
+                    team1_id:, team2_id: )
 
     ## note - do NOT care about minutes in penalty shootout
     ##   check for period == 11 (penalty shotout!!)
@@ -31,8 +32,9 @@ def build_penalty( h, players:,
 
 
      ##########
-     ##  0 - goal   (when penalty awared used before)
+     ##  0 - goal   (when penalty awarded used before)
      ## 41 - penalty goal
+     ##
      ## 46 - penalty missed
      ##   Dragan STOJKOVIC (Yugoslavia) rattles the crossbar from the spot!
      ## 51 - penalty missed
@@ -78,27 +80,27 @@ def build_penalty( h, players:,
 =end
 
       if idPlayer.nil?
-         puts "!! no idPlayer for penalty!"
+         puts "!! no idPlayer for penalty (timeline event):"
          pp h
-          ##exit 1
+          ## exit 1
           ## use 'N.N.'
 
-          rec[ :name ] = 'N.N.'
-
+        rec[ :player ] = Player::PLAYER_NIL
       else
-        rec[ :name ] = players.find!( idPlayer )[:name]
+        rec[ :player ] = players.find!( idPlayer )
       end
 
-       rec[:meta] = {  type: type,
+       rec[:more] = {  type: type,
                        desc: desc(h['EventDescription'])  ## add event desc too - why? why not?
                     }
-     rec
+
+     new( **rec )
 end
 
 
 
 
-def build_penalties( recs, players:,
+def self._build_ary( recs, players:,
                            team1_id:, team2_id: )
      ################
      ## type:
@@ -125,8 +127,40 @@ def build_penalties( recs, players:,
                         end
 
 
-    recs = recs.map { |h| build_penalty( h, players: players,
-                                            team1_id: team1_id,
-                                            team2_id: team2_id ) }
+    recs = recs.map { |h| build( h, players: players,
+                                    team1_id: team1_id,
+                                    team2_id: team2_id ) }
     recs
 end
+
+
+
+attr_reader :player, :team,
+            :score, :scored,
+            :more
+
+def initialize( player:,
+                team:,
+                score:,
+                scored:,
+                more: {} )
+   @player = player
+   @team   = team    ## e.g. 1|2
+   @score  = score   ## e.g. [1,0]
+   @scored = scored  ## e.g. true|false
+   @more   = more
+end
+
+
+def as_json(*)
+      h = {
+            'name'     => player.name,
+            'score'    => score,
+            'scored'   => scored,
+            'team'     => team,
+          }
+
+       h['more']   = more    unless more.empty?
+       h
+end
+end  # class Penalty

data/lib/fifadat/models/player.rb

@@ -0,0 +1,218 @@
+
+#
+# note - players here are for lineup (subs+bookings) and incl. starter/bench AND pos etc.
+#               do NOT use for team squads
+
+
+# TYPE_PLAYER_POS = {
+#   0 => 'GK',
+#   1 => 'DF',
+#   2 => 'MF',
+#   3 => 'FW',
+#   4 => '??',
+#   5 => '??',
+#   6 => '??'
+# }
+
+
+class Player
+
+
+###
+## keep Card nested here - why? why not?
+class Card
+
+   attr_reader :player, :type, :minute
+   def initialize( player:, type:, minute: )
+      @player = player
+      @type   = type
+      @minute = minute
+   end
+
+   ## only print name and minute for now - why? why not?
+   def as_json(*)
+      h = {
+            'name'     => player.name,
+            'minute'   => minute
+          }
+      h
+   end
+end  # class Card
+
+
+
+def self._build_ary( recs )
+    recs.map { |h| build( h ) }
+end
+
+
+def self.build( h )
+
+   name       = desc( h['PlayerName'] )
+   short_name = desc( h['ShortName'] )
+
+   if name.nil?
+     ## "PlayerName"=>[],
+     ## "ShortName"=>[{"Locale"=>"en-gb", "Description"=>"S. Lainer"}],
+
+     ## hack:
+     ##  use shortname
+      name = short_name
+   end
+
+   if name.nil?
+      ## puts "name is nil:"
+      ## pp h
+      ## exit 1
+      ##  report/log error/warn
+      ##
+      ## quick fix use N.N. for now
+      name = 'N.N.'
+   end
+
+   ## name = norm_player( name )
+
+
+   ##
+   ##  todo/check - add IdCountry if available??
+
+   ##  1 -  starter
+   ##  2 -  bench
+
+   status = h['Status']
+   assert( [1,2].include?( status ), "player status 1,2 expected; got #{h.inspect}")
+
+   ## what is pos 6 ??
+   ## e.g.
+   ##   !! ASSERT FAILED
+   ## {"IdPlayer"=>"419456", "IdTeam"=>"32759", "ShirtNumber"=>4, "Status"=>1,
+   ## "PlayerName"=>[{"Locale"=>"en-GB", "Description"=>"Ismaila COULIBALY"}],
+   ##  "ShortName"=>[{"Locale"=>"en-GB", "Description"=>"Ismaila COULIBALY"}],
+   ## "Position"=>6, "PlayerPicture"=>nil,
+   ## "FieldStatus"=>2, "LineupX"=>nil, "LineupY"=>nil}
+   ##
+   ## what is pos 5 ??
+   ##  e.g.
+   ## {"IdPlayer"=>"7czui1ih46j3zitzysxvjqjv8", "IdTeam"=>"2000019848", "ShirtNumber"=>33,
+   ##  "Status"=>1,
+   ## "PlayerName"=>[{"Locale"=>"en-gb", "Description"=>"Maximilian Hennig"}],
+   ## "ShortName"=>[{"Locale"=>"en-gb", "Description"=>"M. Hennig"}],
+   ## "Position"=>5, "PlayerPicture"=>nil, "FieldStatus"=>2, "LineupX"=>nil, "LineupY"=>nil}
+   ##
+   ## what is pos 4 ??
+   ##  {"IdPlayer"=>"254150", "IdTeam"=>"2000017585", "ShirtNumber"=>15,
+   ## "Status"=>2, "SpecialStatus"=>nil, "Captain"=>false,
+   ## "PlayerName"=>[{"Locale"=>"en-GB", "Description"=>"Nemanja RNIC"}],
+   ## "ShortName"=>[{"Locale"=>"en-gb", "Description"=>"N. Rnić"}],
+   ## "Position"=>4, "PlayerPicture"=>nil, "FieldStatus"=>1, "LineupX"=>nil, "LineupY"=>nil}
+
+
+   pos = h['Position']
+   assert( [0,1,2,3,4,5,6].include?( pos ), "player pos 0,1,2,3,4,5,6 expected; got #{h.inspect}" )
+
+   ##    0 - is always goal keeper
+   ##   check meaning of 1 to 6
+   ##     on website !!!
+   ##       pos is NOT (simply) matching tactics/formation (index number)!!
+
+   rec = { id:      h['IdPlayer'],
+           name:        name,
+           short_name:  short_name,
+           status:      status,
+           pos:         pos,
+        }
+
+    ## check for shirtNumber too
+    num = h['ShirtNumber']
+    rec[:num]     = num  if num
+
+    rec[:captain]  = true   if h['Captain']
+
+
+    new( **rec )
+end
+
+
+
+
+
+attr_reader :id, :name, :short_name,
+            :status, :pos,
+            :captain, :num
+
+
+attr_accessor :count,
+              :y, :yr, :r     ## yello/yellowred/red cards
+
+
+
+
+def initialize( id:,
+                name:,
+                status:,   ## 1 - starter, 2 - bench
+                pos:,
+                short_name: nil,
+                captain: false,
+                num: nil         ## shirt/jersey number
+               )
+    @id = id
+    @name = name
+    @short_name = name
+    @status = status
+    @pos  = pos
+    @captain = captain
+    @num  = num
+
+    @count = 0
+
+    @y  = nil
+    @yr = nil
+    @r  = nil
+end
+
+PLAYER_NIL = new( id:    '<nil>',
+                  name:  'N.N.',
+                  status: nil,
+                  pos:    nil
+                )
+
+
+def starter?() status == 1; end
+def bench?()   status == 2; end
+
+## add alias yellow_card? or y? - why? why not?
+def yellow?()     y.is_a?(Card); end
+def yellowred?()  yr.is_a?(Card); end
+def red?()        r.is_a?(Card); end
+
+
+
+
+def ==(other)
+    return false   unless other.is_a?(Player)
+
+    self.name       == other.name &&
+    self.short_name == other.short_name
+end
+
+
+def as_json(*)
+      h = {
+            'name'           => name,
+            'short_name'     => short_name,
+            'id'             => id,
+            ##  use starter|bench !!!
+            'status'         => status,
+            ##  todo - map pos
+            'pos'            => pos,
+          }
+
+
+       h['captain'] = captain  if captain
+       h['num']     = num      if num
+       h
+end
+
+
+
+end  # class Player

data/lib/fifadat/models/stadium.rb

@@ -0,0 +1,98 @@
+
+class Stadium
+
+
+def self.build( h )
+   if h
+     ## note - for now stadiums have no ids!!!!!
+     ##    check if any ids found
+     id         = h['IdStadium']
+     id_country = h['IdCountry']
+
+     ## same with city - no ids really in use
+     ##    id_city    = h['IdCity']
+
+     name      = desc( h['Name'] )
+     city_name = desc( h['CityName'] )
+
+     if name.nil?
+       puts "stadium without name:"
+       pp h
+       exit 1
+     end
+
+     ## name, city_name = norm_stadium( name, city_name: city_name )
+
+     new( id: id,
+          name: name,
+          city: city_name,
+          country: id_country,
+          street: h['Street']
+          )
+
+   else    ## assume nil - dummy record
+       STADIUM_NIL
+   end
+end
+
+
+
+attr_reader :id, :name, :street, :city, :country
+attr_accessor :count
+def initialize( name:, country:, city:,
+                 street: nil,
+                 id: nil )
+   @name = name
+   @country = country
+   @city = city
+   @street = street
+
+    if id.nil?
+        ## auto-generate id
+        ##  use slug of name plus id_city
+        ## add city name
+        ##  fix- add   0-9 & dash(-) to name too - why? why not?
+        id  =       name.downcase.gsub( /[^a-z]/, '' )
+        id += "_" + city.downcase.gsub( /[^a-z]/, '' )
+    end
+   @id  = id
+
+   ## note - count matches by (home) teams!!!
+   @count = Hash.new(0)
+end
+
+
+## dummy/nil record
+STADIUM_NIL = self.new(  id:      '<nil>',
+                         name:    '?',
+                         city:    '?',   ## use nil - why? why not?
+                         country: '?'    ## use nil - why? why not?
+                      )
+
+
+def ==(other)
+    return false   unless other.is_a?(Stadium)
+
+    ## note - ignore street (and always empty id) for now!!!
+    self.name    == other.name &&
+    self.city    == other.city &&
+    self.country == other.country
+end
+
+
+def as_json(*)
+      h = {
+            'name'     => name
+          }
+
+       h['street']    = street   if street
+       h['city']      = city     if city
+       h['country']   = country  if country
+
+       h['count'] = count
+       h
+end
+
+
+
+end # class Stadium

data/lib/fifadat/models/stage.rb

@@ -0,0 +1,99 @@
+=begin
+[{"IdStage": "286472",
+    "IdSeason": "286466",
+    "SeasonName":
+     [{"Locale": "en-GB", "Description": "FIFA Club World Cup Morocco 2022™"}],
+    "IdCompetition": "107",
+
+    "SequenceOrder": 6,
+    "Name": [{"Locale": "en-GB", "Description": "Final"}],
+    "StartDate": "2023-02-11T19:00:00Z",
+    "EndDate": "2023-02-11T19:00:00Z",
+    "StageLevel": null,
+    "Type": 0,  add ---??
+    "Properties": {"IdIFES": "286472"},
+    "IsUpdateable": null},
+=end
+
+
+
+class Stage
+def self.build( h )
+   name       = desc( h['Name'] )
+   seq        = h['SequenceOrder']
+   level      = h['StageLevel']      ## note - is optional
+
+   start_date = nil
+   end_date   = nil
+
+   if h['StartDate'] && h['EndDate']
+     ## note - start/end dates are utc (NOT local)
+     start_date = parse_date_utc( h['StartDate'] )   ## expects  ...:00Z format
+     end_date   = parse_date_utc( h['EndDate'] )     ## expects  ...:00Z format
+
+     ## check if HH::MM is 00:00
+     ##    only use date for now; ignore time
+     ##     report warn(ing) if time present!!!
+     if start_date.hour != 0 || start_date.min != 0 ||
+        end_date.hour != 0   || end_date.min != 0
+        ## issue warn   start/end_date with HH:MM (NOT 00:00)
+        puts "!! warn:  stage start/end_date with HH:MM  (expected 00:00)"
+        pp h
+     end
+    else
+       ##    maybe add to log later - why? why not?
+       ## puts "!! warn:  stage witouout start/end_date"
+       ## pp h
+   end
+
+   new( name: name,
+        seq: seq,
+        start_date: start_date ? start_date.to_date : nil,
+        end_date:   end_date   ? end_date.to_date : nil,
+        level: level )
+end
+
+
+
+##
+##  note - seq might be same for different stages e.g.
+##        "seq": 2,
+##         "name": "Relegation Round",
+##
+##      "seq": 2,
+##      "name": "Championship Round",
+attr_reader :name, :seq, :level,
+            :start_date, :end_date
+
+attr_accessor :count
+
+def initialize( name:, seq:,
+                level: nil,
+                start_date: nil,
+                end_date: nil
+                )
+    @name = name
+    @seq  = seq    # e.g. 1,2,3,4,5
+    @start_date = start_date
+    @end_date   = end_date
+    @level     = level
+    @count = 0    ## match (usage/reference) count(er)
+end
+
+
+def as_json(*)
+      h = {
+            'seq'     => seq,
+            'name'    => name
+           }
+
+      h['start_date'] = start_date.strftime('%Y-%m-%d')    if start_date
+      h['end_date']   = end_date.strftime('%Y-%m-%d')      if end_date
+
+      h['level'] = level   if level
+      h['count'] = count
+      h
+end
+
+
+end   # class Stage