forked from Trygve/otime
396 lines
14 KiB
Python
396 lines
14 KiB
Python
import copy
|
|
import datetime
|
|
import csv
|
|
import re
|
|
import xml.etree.ElementTree as ET
|
|
|
|
class event:
|
|
def __init__(self, eventid, name, **kwargs):
|
|
self.id = eventid
|
|
self.name = name
|
|
|
|
self.courses = []
|
|
self.o_classes = []
|
|
self.runners = []
|
|
self.card_punches= []
|
|
def add_course(self, *args):
|
|
for n in args:
|
|
self.courses.append(n)
|
|
|
|
def add_o_class(self, *args):
|
|
for n in args:
|
|
self.o_classes.append(n)
|
|
|
|
def add_runners(self, *args):
|
|
for n in args:
|
|
self.runners.append(n)
|
|
def import_ttime_cnf(self, ttime_file):
|
|
self.add_course(*courses_from_ttime_conf(ttime_file))
|
|
self.add_o_class(*classes_from_ttime_conf(ttime_file, self.courses))
|
|
|
|
def import_ttime_db(self, ttime_file):
|
|
self.add_runners(*ttime_db_to_class(ttime_file, self.o_classes))
|
|
|
|
def import_mtr_file(self, mtr_file):
|
|
ttime_mtr_to_class(mtr_file, self.runners)
|
|
|
|
# MIDLERTIDIG
|
|
def append_punch_list(self, punches):
|
|
for n in self.runners:
|
|
for i in punches:
|
|
if n.card == i.card:
|
|
n.controls = list(i.punches.keys())
|
|
n.splits = list(i.punches.values())
|
|
|
|
def get_xml_res(self):
|
|
root = ET.Element('ResultList')
|
|
root.set('xmlns', 'http://www.orienteering.org/datastandard/3.0')
|
|
root.set('xmlns:xsi', 'http://www.w3.org/2001/XMLSchema-instance')
|
|
root.set('iofVersion', '3.0')
|
|
root.set('createTime', datetime.datetime.now().isoformat(timespec='seconds'))
|
|
root.set('creator', 'oTime')
|
|
root.set('status', 'Complete')
|
|
tree = ET.ElementTree(root)
|
|
event = ET.SubElement(root, 'Event')
|
|
xml_child(event, 'Id', self.id)
|
|
xml_child(event, 'Name', self.name)
|
|
for i in self.o_classes:
|
|
#<ClassResult>
|
|
class_result = ET.SubElement(root, 'ClassResult')
|
|
#<Class>
|
|
t = ET.SubElement(class_result, 'Class')
|
|
xml_child(t, 'Name', i.name)
|
|
#<PersonResult>
|
|
runners_same_c = get_runners_in_class(self.runners, i)
|
|
runners_ranked = rank_runners(runners_same_c, i)
|
|
# Put the OK runners first and Active last
|
|
print(len(runners_same_c), len(runners_ranked))
|
|
runners_sorted = [i for i in runners_same_c if i not in runners_ranked]
|
|
print(len(runners_same_c), len(runners_ranked))
|
|
runners_ranked.extend(runners_sorted)
|
|
|
|
print(len(runners_same_c), len(runners_ranked))
|
|
for n in runners_ranked:
|
|
person_result = ET.SubElement(class_result, 'PersonResult')
|
|
#<Person>
|
|
person = ET.SubElement(person_result, 'Person')
|
|
xml_child(person, 'Id', n.id)
|
|
#<Name>
|
|
name = ET.SubElement(person, 'Name')
|
|
xml_child(name, 'Family', n.last)
|
|
xml_child(name, 'Given', n.first)
|
|
#</Name>
|
|
#</Person>
|
|
#<Organisation>
|
|
org = ET.SubElement(person_result, 'Organisation')
|
|
xml_child(org, 'Id', '0')
|
|
xml_child(org, 'Name', n.club)
|
|
country = ET.SubElement(org, 'Country')
|
|
# TODO: hent land fra løperobjektet
|
|
country.text = 'Norway'
|
|
country.set('code', 'NOR')
|
|
#</Organisation>
|
|
#<Result>
|
|
result = ET.SubElement(person_result, 'Result')
|
|
if len(n.splits) > 2:
|
|
xml_child(result, 'StartTime', n.s_time.isoformat())
|
|
xml_child(result, 'FinishTime', n.f_time.isoformat())
|
|
xml_child(result, 'Time', n.totaltime())
|
|
if n.status() == 'OK':
|
|
#<TimeBehind>
|
|
xml_child(result, 'TimeBehind', n.totaltime() - runners_ranked[0].totaltime())
|
|
#</TimeBehind>
|
|
xml_child(result, 'Position', n.rank(self.runners))
|
|
xml_child(result, 'Status', n.status())
|
|
#<SplitTime>
|
|
for code,split in zip(n.o_class.course.codes, n.res_splits(), strict=True):
|
|
st = ET.SubElement(result, 'SplitTime')
|
|
xml_child(st, 'ControlCode', code)
|
|
xml_child(st, 'Time', split)
|
|
#</SplitTime>
|
|
elif n.status() == 'Disqualified':
|
|
xml_child(result, 'Status', n.status())
|
|
for code in n.o_class.course.codes:
|
|
st = ET.SubElement(result, 'SplitTime')
|
|
xml_child(st, 'ControlCode', code)
|
|
for control,split in zip(n.controls, n.splits):
|
|
if code == control:
|
|
xml_child(st, 'Time', split)
|
|
else:
|
|
xml_child(result, 'Status', n.status())
|
|
else:
|
|
xml_child(result, 'Status', n.status())
|
|
#</Result>
|
|
#</PersonResult>
|
|
#</Class>
|
|
ET.indent(root, space=' ', level=0)
|
|
return tree
|
|
class runner:
|
|
def __init__(self, eventorid, first, last, club, country, card, o_class, controls, splits):
|
|
self.id = eventorid
|
|
self.first = first
|
|
self.last = last
|
|
self.club = club
|
|
self.country = country
|
|
self.card = card
|
|
self.o_class = o_class
|
|
self.controls = controls
|
|
self.splits = splits
|
|
self.s_time = 0
|
|
self.f_time = 0
|
|
|
|
def fullname(self):
|
|
return '{} {}'.format(self.first, self.last)
|
|
def check_codes(self):
|
|
# Returns False if not ok and touple if ok
|
|
return contains(self.o_class.course.codes, self.controls)
|
|
def totaltime(self):
|
|
return self.splits[-2]
|
|
|
|
def status(self):
|
|
if self.controls == []:
|
|
return 'Active'
|
|
elif self.check_codes():
|
|
return 'OK'
|
|
elif self.check_codes() == False:
|
|
return 'Disqualified'
|
|
def rank(self, allrunners):
|
|
c_ranked = rank_runners(allrunners, self.o_class)
|
|
return c_ranked.index(self) + 1
|
|
def res_splits(self):
|
|
control_map = self.check_codes()
|
|
splits = []
|
|
for n in control_map:
|
|
splits.append(self.splits[n])
|
|
return splits
|
|
class card_punch:
|
|
def __init__(self, card, punches, s_time, f_time):
|
|
self.card = card
|
|
self.punches = punches
|
|
self.s_time = s_time
|
|
self.f_time = f_time
|
|
def __repr__(self):
|
|
return f'card({self.card}) punches({self.punches})'
|
|
|
|
def list_from_mtr_f(mtr_f):
|
|
csvreader = csv.reader(open(mtr_f))
|
|
fields = next(csvreader)
|
|
|
|
fields = []
|
|
rows = []
|
|
|
|
cards = []
|
|
# hver rad er brikkenummer med tilhørende info
|
|
for row in csvreader:
|
|
rows.append(row)
|
|
controls = []
|
|
splits = []
|
|
# postkodene kommer på oddetall fra og med den 11. De blir hevet inn i controls
|
|
for item in row[11::2]:
|
|
if item != '000' and item != '0000' and item != '00000':
|
|
controls.append(int(item))
|
|
# strekktidene kommer på partall fra og med den 12. De blir hevet i splits.
|
|
for item in row[12::2]:
|
|
if item != '000' and item != '0000' and item != '00000':
|
|
splits.append(int(item))
|
|
# looper gjonnom løperobjektene og legger til poster og strekktider + start og sluttid
|
|
# usikker på om dette er riktig klokeslett
|
|
tl = row[5].split(' ')
|
|
tl[0] = tl[0].split('.')
|
|
tl[0][2] = '20' + tl[0][2]
|
|
tl[0] = list(map(int, tl[0]))
|
|
tl[1] = tl[1].split(':')
|
|
tl[1][2] = float(tl[1][2])
|
|
tl[1] = list(map(int, tl[1]))
|
|
f_time = datetime.datetime(tl[0][2], tl[0][1], tl[0][0], tl[1][0], tl[1][1], tl[1][2])
|
|
if controls[-1] == 250:
|
|
s_time = f_time - datetime.timedelta(seconds = splits[-2])
|
|
else:
|
|
pass
|
|
#s_time = f_time
|
|
cards.append(card_punch(int(row[6]), dict(zip(controls, splits)), s_time, f_time))
|
|
return cards
|
|
class course:
|
|
def __init__(self, name, codes):
|
|
self.name = name
|
|
self.codes = codes
|
|
def __repr__(self):
|
|
return f'name({self.name})'
|
|
|
|
class o_class:
|
|
def __init__(self, name, course):
|
|
self.name = name
|
|
self.course = course
|
|
def __repr__(self):
|
|
return f'name({self.name})'
|
|
|
|
def courses_from_ttime_conf(ttime_file = 'sc_2021_ttime/ttime.cnf.txt'):
|
|
courses = []
|
|
conf = open(ttime_file, 'r', encoding='latin_1').readlines()
|
|
for line in conf:
|
|
if '-codes' in line:
|
|
code_list = re.search(r'(?<=\")(.*?)(?=\")', line).group().split(';')
|
|
loops = 0
|
|
for n in code_list:
|
|
n = n.split(',')
|
|
loops += 1
|
|
n = list(map(int, n))
|
|
courses.append(course('course_'+str(loops), n))
|
|
return courses
|
|
def classes_from_ttime_conf(ttime_file, courses):
|
|
o_classes = []
|
|
conf = open(ttime_file, 'r', encoding='latin_1').readlines()
|
|
for line in conf:
|
|
if '-courses' in line:
|
|
raw_courselist = re.search(r'(?<=\")(.*?)(?=\")', line).group().split(';')
|
|
loops = 0
|
|
for n in raw_courselist:
|
|
n = n.split(',')
|
|
for i in n:
|
|
o_classes.append(o_class(i,courses[loops]))
|
|
loops += 1
|
|
|
|
|
|
return o_classes
|
|
|
|
def xml_to_class(xml_file, o_class_list=[]):
|
|
tree = ET.parse(xml_file)
|
|
root = tree.getroot()
|
|
runnerarray = []
|
|
|
|
for person_root in root[1:]:
|
|
first = person_root[1][1][1].text
|
|
last = person_root[1][1][0].text
|
|
try:
|
|
club = person_root[2][1].text
|
|
except:
|
|
club = "None"
|
|
country = person_root[1][3].text
|
|
try:
|
|
card = int(person_root[3].text)
|
|
except:
|
|
card = 0
|
|
try:
|
|
xml_class_str = person_root[4][1].text
|
|
except:
|
|
# VELDIG MIDLERTIDIG
|
|
runner_o_class = o_class_list[0]
|
|
else:
|
|
for i in o_class_list:
|
|
if i.name == xml_class_str:
|
|
runner_o_class = i
|
|
break
|
|
# Gjør sånn at den lager nye o klasser om den ikke finnes fra før
|
|
runnerarray.append(runner(first, last, club, country, card, runner_o_class, [], []))
|
|
return runnerarray
|
|
def ttime_db_to_class(ttime_file, o_class_list=[]):
|
|
csvreader = csv.reader(open(ttime_file, 'r', encoding='latin_1'), delimiter=';',)
|
|
runnerarray = []
|
|
for row in csvreader:
|
|
eventorid = row[0]
|
|
country = ''
|
|
name = row[2].split(',')
|
|
first = name[1].strip()
|
|
last = name[0]
|
|
try:
|
|
club = row[4]
|
|
except:
|
|
club = "None"
|
|
try:
|
|
card = int(row[6])
|
|
except:
|
|
card = 0
|
|
try:
|
|
raw_class_str = row[3]
|
|
except:
|
|
# VELDIG MIDLERTIDIG
|
|
runner_o_class = o_class_list[0]
|
|
else:
|
|
for i in o_class_list:
|
|
if i.name == raw_class_str:
|
|
runner_o_class = i
|
|
break
|
|
# TODO: Gjør sånn at den lager nye o klasser om den ikke finnes fra før
|
|
runnerarray.append(runner(eventorid, first, last, club, country, card, runner_o_class, [], []))
|
|
return runnerarray
|
|
|
|
# Denne fjernes når card_punch klasses er ferdig
|
|
def ttime_mtr_to_class(csv_file, runnerarray):
|
|
csvreader = csv.reader(open(csv_file))
|
|
fields = next(csvreader)
|
|
|
|
fields = []
|
|
rows = []
|
|
# hver rad er brikkenummer med tilhørende info
|
|
for row in csvreader:
|
|
rows.append(row)
|
|
for row in rows:
|
|
controls = []
|
|
splits = []
|
|
# postkodene kommer på oddetall fra og med den 11. De blir hevet inn i controls
|
|
for item in row[11::2]:
|
|
if item != '000' and item != '0000' and item != '00000':
|
|
controls.append(int(item))
|
|
# strekktidene kommer på partall fra og med den 12. De blir hevet i splits.
|
|
for item in row[12::2]:
|
|
if item != '000' and item != '0000' and item != '00000':
|
|
splits.append(int(item))
|
|
# looper gjonnom løperobjektene og legger til poster og strekktider + start og sluttid
|
|
for runner in runnerarray:
|
|
if runner.card == int(row[6]):
|
|
runner.controls = controls
|
|
runner.splits = splits
|
|
|
|
# usikker på om dette er riktig klokeslett
|
|
if len(runner.splits) > 2:
|
|
tl = row[5].split(' ')
|
|
tl[0] = tl[0].split('.')
|
|
tl[0][2] = '20' + tl[0][2]
|
|
tl[0] = list(map(int, tl[0]))
|
|
tl[1] = tl[1].split(':')
|
|
tl[1][2] = float(tl[1][2])
|
|
tl[1] = list(map(int, tl[1]))
|
|
f_time = datetime.datetime(tl[0][2], tl[0][1], tl[0][0], tl[1][0], tl[1][1], tl[1][2])
|
|
s_time = f_time - datetime.timedelta(seconds = runner.totaltime())
|
|
runner.f_time = f_time
|
|
runner.s_time = s_time
|
|
|
|
def contains(small, big):
|
|
valid = True
|
|
mark = 0
|
|
map_bl = []
|
|
for i in small:
|
|
for n,control in enumerate(big[mark:]):
|
|
if i == control:
|
|
mark += n
|
|
map_bl.append(mark)
|
|
break
|
|
else:
|
|
valid = False
|
|
if valid:
|
|
return map_bl
|
|
else:
|
|
return False
|
|
|
|
def get_runners_in_class(runners, o_class):
|
|
list_filtrd = []
|
|
for i in runners:
|
|
marker = 0
|
|
if i.o_class == o_class:
|
|
list_filtrd.append(i)
|
|
|
|
return list_filtrd
|
|
|
|
def rank_runners(allrunners, o_class):
|
|
runners = get_runners_in_class(allrunners, o_class)
|
|
runners_ranked = []
|
|
for i in runners:
|
|
if i.status() == 'OK':
|
|
runners_ranked.append(i)
|
|
runners_ranked.sort(key=lambda x: x.totaltime())
|
|
return runners_ranked
|
|
|
|
def xml_child(parent, tag, content):
|
|
e = ET.SubElement(parent, tag)
|
|
e.text = str(content)
|