from copy import copy import datetime import csv import re import json import xml.etree.ElementTree as ET from fpdf import FPDF # The event object stores all the event data. # A .otime file is more or less just a json dump of the Event object. class Event: def __init__(self, eventid, name, **kwargs): self.id = eventid self.name = name try: self.courses = kwargs['courses'] except KeyError: self.courses = [] try: self.o_classes = kwargs['o_classes'] except KeyError: self.o_classes = [] try: self.runners = kwargs['runners'] except KeyError: self.runners = [] try: self.card_dumps = kwargs['card_dumps'] except KeyError: self.card_dumps = [] 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_xml_entries(self, xml_file): self.add_runners(*runners_from_xml_entries(xml_file, self.o_classes)) def import_ttime_cnf(self, ttime_file): self.add_course(*courses_from_ttime_conf(ttime_file)) ttime_file.seek(0) self.add_o_class(*classes_from_ttime_conf(ttime_file, self.courses)) def import_ttime_db(self, ttime_file): csvreader = csv.reader(ttime_file, delimiter=';',) runnerarray = [] for row in csvreader: if len(row) == 0 or row[1] == '': continue runnerarray.append(Runner.from_string(row, self.o_classes)) self.runners = runnerarray def import_mtr_file(self, mtr_file): self.card_dumps = CardDump.list_from_mtr_f(mtr_file) def match_runners_cards(self): for r in self.runners: for d in self.card_dumps: if r.card == d.card: r.card_r = d def match_runners_o_classes(self): for r in self.runners: for c in self.o_classes: if r.o_class_str == c.name: r.o_class = c def match_o_classes_courses(self): for oc in self.o_classes: for c in self.courses: if oc.course_str == c.name: oc.course = c def match_all(self): self.match_runners_cards() self.match_runners_o_classes() self.match_o_classes_courses() 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: # class_result = ET.SubElement(root, 'ClassResult') # t = ET.SubElement(class_result, 'Class') xml_child(t, 'Name', i.name) # 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 runners_sorted = [i for i in runners_same_c if i not in runners_ranked] runners_ranked.extend(runners_sorted) for n in runners_ranked: if n.status() == 'Active': continue person_result = ET.SubElement(class_result, 'PersonResult') # person = ET.SubElement(person_result, 'Person') xml_child(person, 'Id', n.id) # name = ET.SubElement(person, 'Name') xml_child(name, 'Family', n.last) xml_child(name, 'Given', n.first) # # # org = ET.SubElement(person_result, 'Organisation') xml_child(org, 'Id', n.club_id) xml_child(org, 'Name', n.club) country = ET.SubElement(org, 'Country') # TODO: hent land fra løperobjektet country.text = 'Norway' country.set('code', 'NOR') # # result = ET.SubElement(person_result, 'Result') if hasattr(n, 'card_r') and len(n.card_r.splits) > 2: xml_child(result, 'StartTime', n.card_r.s_time.isoformat()) xml_child(result, 'FinishTime', n.card_r.f_time.isoformat()) xml_child(result, 'Time', n.totaltime()) if n.status() == 'OK': # xml_child(result, 'TimeBehind', n.totaltime() - runners_ranked[0].totaltime()) # xml_child(result, 'Position', n.rank(self.runners)) xml_child(result, 'Status', n.status()) # # TODO: ta utgangspunkt i løypa, ikke det brikka har stempla for code, split in zip(n.card_r.controls, n.card_r.splits): st = ET.SubElement(result, 'SplitTime') xml_child(st, 'ControlCode', code) xml_child(st, 'Time', split) if code == n.res_codes()[-1]: break # elif n.status() == 'Disqualified': xml_child(result, 'Status', n.status()) controls = copy(n.card_r.controls) splits = copy(n.card_r.splits) for code in n.res_codes(): st = ET.SubElement(result, 'SplitTime') xml_child(st, 'ControlCode', code) for control, split in zip(controls, splits): if code == control: xml_child(st, 'Time', split) controls.remove(control) splits.remove(split) break else: xml_child(result, 'Status', n.status()) else: xml_child(result, 'Status', n.status()) # # # ET.indent(root, space=' ', level=0) return tree def create_json_file(self): rdicts = [] for runner in self.runners: rdicts.append(runner.asdict()) cdicts = [] for course in self.courses: cdicts.append(course.asdict()) ocdicts = [] for o_class in self.o_classes: ocdicts.append(o_class.asdict()) ddicts = [] for dump in self.card_dumps: ddicts.append(dump.asdict()) json_data = { 'id': self.id, 'name': self.name, 'runners': rdicts, 'courses': cdicts, 'o_classes': ocdicts, 'card_dumps': ddicts } return json.dumps(json_data, sort_keys=True, indent=4) # Get event object from .otime json file def from_json(f): data = json.load(f) runners = [] for r in data['runners']: runners.append(Runner(r['id'], r['first'], r['last'], club_id=r['club_id'], club=r['club'], country=r['country'], card=r['card'], o_class_str=r['o_class_str'], fork=r['fork'],start_time=r['start_time'])) courses = [] for c in data['courses']: courses.append(Course(c['name'], c['codes'], forked=c['forked'], variations=c['variations'])) o_classes = [] for c in data['o_classes']: o_classes.append(OClass(c['name'], c['course_str'], None)) card_dumps = [] for d in data['card_dumps']: card_dumps.append(CardDump(d['card'], d['controls'], d['splits'], datetime.datetime.fromisoformat(d['read_time']), datetime.datetime.fromisoformat(d['s_time']), datetime.datetime.fromisoformat(d['f_time']))) return Event(data['id'], data['name'], runners=runners, courses=courses, o_classes=o_classes, card_dumps=card_dumps) def create_start_list_pdf(self, file_name): pdf = FPDF() pdf.add_page() pdf.add_font("DejaVuSans", fname="/usr/share/fonts/truetype/DejaVuSans.ttf") pdf.set_font("DejaVuSans", size=10) line_height = pdf.font_size * 2 col_width = pdf.epw / 4 # distribute content evenly for runner in self.runners: pdf.multi_cell(col_width, line_height, runner.fullname(), border=1, ln=3, max_line_height=pdf.font_size, align='L') pdf.multi_cell(col_width, line_height, runner.o_class.name, border=1, ln=3, max_line_height=pdf.font_size) pdf.multi_cell(col_width, line_height, str(runner.card), border=1, ln=3, max_line_height=pdf.font_size) if runner.start_time != None: pdf.multi_cell(col_width, line_height, str(runner.start_time), border=1, ln=3, max_line_height=pdf.font_size) else: pdf.multi_cell(col_width, line_height, '', border=1, ln=3, max_line_height=pdf.font_size) pdf.ln(line_height) pdf.output(file_name) # The runner object stores all the data specific to a runner. class Runner: def __init__(self, runner_id, first, last, **kwargs): self.id = runner_id self.first = first self.last = last try: self.club = kwargs['club'] except KeyError: self.club = None try: self.club_id = kwargs['club_id'] except KeyError: self.club_id = None try: self.country = kwargs['country'] except KeyError: self.country = None try: self.card = kwargs['card'] except KeyError: self.card = 0 try: self.o_class_str = kwargs['o_class_str'] except KeyError: self.o_class = None try: self.o_class = kwargs['o_class'] except KeyError: self.o_class = None try: self.fork = kwargs['fork'] except KeyError: self.fork = 0 try: self.start_time = kwargs['start_time'] except KeyError: self.start_time = None #self.o_class = o_class #self.start_time = start_time def from_string(tt_line, o_classes): #https://web.archive.org/web/20191229124046/http://wiki.ttime.no/index.php/Developer eventorid = tt_line[0] country = '' name = tt_line[2].split(',') try: first = name[1].strip() except: first = '' last = name[0] try: club = tt_line[4] except: club = "None" try: card = int(tt_line[6]) except: card = 0 runner_o_class = None try: raw_class_str = tt_line[3] except: # VELDIG MIDLERTIDIG runner_o_class = None else: if raw_class_str != '': for i in o_classes: if i.name == raw_class_str: runner_o_class = i break else: runner_o_class = None # TODO: Gjør sånn at den lager nye o klasser om den ikke finnes fra før options = tt_line[5].split(',') try: club_id = options[options.index('A')+3] except: club_id = 0 try: start_time = options[options.index('U')+1] except: start_time = None return Runner(eventorid, first, last, club=club, club_id=club_id, country=country, card=card, o_class_str=raw_class_str, o_class=runner_o_class, start_time=start_time) def fullname(self): return '{} {}'.format(self.first, self.last) def check_codes(self): return contains(self.res_codes(), self.card_r.controls) def totaltime(self): f_control = self.res_codes()[-1] try: index = self.card_r.controls.index(f_control) return self.card_r.splits[index] except: return 0 def status(self): if hasattr(self, 'card_r') == False or self.o_class == None: 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_codes(self): if self.o_class.course.forked == False: return self.o_class.course.codes else: return self.o_class.course.variations[self.fork] # Used for making result files and tables def res_splits(self): splits_cpy = self.card_r.splits.copy() for control in self.card_r.controls: if control not in self.res_codes(): index = self.card_r.controls.index(control) split = self.card_r.splits[index] splits_cpy.remove(split) return splits_cpy # list def asdict(self): return { 'id': self.id, 'first': self.first, 'last': self.last, 'club_id': self.club_id, 'club': self.club_id, 'country': self.country, 'card': self.card, 'o_class_str': self.o_class_str, 'fork' : self.fork, 'start_time': self.start_time } class CardDump: def __init__(self, card, controls, splits, read_time, s_time, f_time): self.card = card self.controls = controls self.splits = splits self.read_time = read_time self.s_time = s_time self.f_time = f_time def __repr__(self): return f'card({self.card}) controls({self.controls}) splits({self.splits})' def from_mtr_bytes(datamsg): card = int.from_bytes(datamsg[20:23], 'little') #Extract codes and splits: controls = [] splits = [] splits_offset = 26 code_numbytes = 1 time_numbytes = 2 split_numbytes = code_numbytes + time_numbytes for split_index in range(50): code_offset = splits_offset + split_index * split_numbytes time_offset = code_offset + code_numbytes code = int.from_bytes(datamsg[code_offset:code_offset+code_numbytes], 'little') time = int.from_bytes(datamsg[time_offset:time_offset+time_numbytes], 'little') if code != 0: controls.append(code) splits.append(time) # Extract start time: year = int.from_bytes(datamsg[8:9], 'little') month = int.from_bytes(datamsg[9:10], 'little') day = int.from_bytes(datamsg[10:11], 'little') hours = int.from_bytes(datamsg[11:12], 'little') minutes = int.from_bytes(datamsg[12:13], 'little') seconds = int.from_bytes(datamsg[13:14], 'little') milliseconds = int.from_bytes(datamsg[14:16], 'little') read_time = datetime.datetime(year, month, day, hours, minutes, seconds, milliseconds) if len(controls) > 2: s_time = read_time - datetime.timedelta(seconds = splits[-1]) f_time = read_time - (datetime.timedelta(seconds=splits[-1]) + datetime.timedelta(seconds=splits[-2])) else: s_time = read_time f_time = read_time return(CardDump(card, controls, splits, read_time, s_time, f_time)) def list_from_mtr_f(mtr_f): csvreader = csv.reader(mtr_f) rows = [] cards = [] # hver rad er brikkenummer med tilhørende info for row in csvreader: if len(row) == 0: continue 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 == '250': controls.append(int(item)) break elif item == '000': break else: 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 == '00000': break else: 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])) read_time = datetime.datetime(tl[0][2], tl[0][1], tl[0][0], tl[1][0], tl[1][1], tl[1][2]) if len(controls) > 2 and len(splits) > 2: s_time = read_time - datetime.timedelta(seconds = splits[-1]) f_time = read_time - (datetime.timedelta(seconds = splits[-1]) + datetime.timedelta(seconds = splits[-2])) else: s_time = read_time f_time = read_time cards.append(CardDump(int(row[6]), controls, splits, read_time, s_time, f_time)) return cards def asdict(self): return { 'card': self.card, 'controls': self.controls, 'splits': self.splits, 'read_time': self.read_time.isoformat(), 's_time': self.s_time.isoformat(), 'f_time': self.f_time.isoformat() } # Stored in Event.courses class Course: def __init__(self, name, codes, **kwargs): self.name = name self.codes = codes try: self.forked = kwargs['forked'] except KeyError: self.forked = False try: self.variations = kwargs['variations'] except KeyError: self.variations = None def __repr__(self): return f'name({self.name})' def asdict(self): return { 'name': self.name, 'codes': self.codes, 'forked': self.forked, 'variations': self.variations } # Stored in Event.o_classes class OClass: def __init__(self, name, course_str, course): self.name = name self.course_str = course_str self.course = course def __repr__(self): return f'name({self.name})' def asdict(self): return { 'name': self.name, 'course_str': self.course_str } # TODO: Take string instead of file. def courses_from_ttime_conf(ttime_file): courses = [] conf = ttime_file.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 = ttime_file.readlines() for line in conf: if '-courses' in line: raw_courselist = re.search(r'(?<=\")(.*?)(?=\")', line).group().split(';') loops = 0 for n in raw_courselist: split = n.split(',') for i in split: o_classes.append(OClass(i, courses[loops].name, courses[loops])) loops += 1 return o_classes def runners_from_xml_entries(xml_file, o_classes=[]): tree = ET.parse(xml_file) root = tree.getroot() runnerarray = [] for person_root in root[1:]: rid = person_root[1][0].text first = person_root[1][1][1].text last = person_root[1][1][0].text try: club_id = person_root[2][0].text 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 runner_o_class = None try: xml_class_str = person_root[4][1].text except: # VELDIG MIDLERTIDIG runner_o_class = o_class_list[0] else: for i in o_classes: 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 start_time = None runnerarray.append(Runner(rid, first, last, club=club, club_id=club_id, country=country,card=card, o_class_str=xml_class_str, o_class=runner_o_class, start_time=start_time)) #print(rid, first, last, club_id, club, card, xml_class_str) return runnerarray # Checks if small list is in big list 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): # Filters out runner objects that dont have the correct 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 # Used to make creating xml files easier def xml_child(parent, tag, content): e = ET.SubElement(parent, tag) e.text = str(content)