def course_double_clicked(index):
try:
if index.row() < len(race().courses):
dialog = CourseEditDialog(race().courses[index.row()])
dialog.exec()
except Exception as e:
logging.error(str(e))
def show_person_info(self):
bib_or_name = self.item_bib_or_name.text() # type: str
self.label_person_info.setText('')
person = None
if bib_or_name:
if bib_or_name.isdigit():
person = memory.find(memory.race().persons,
bib=int(bib_or_name))
else:
for p in memory.race().persons:
if bib_or_name.lower() in p.full_name.lower():
person = p
break
if person:
info = person.full_name
if person.group:
info = '{}\n{}: {}'.format(info, _('Group'),
person.group.name)
if person.card_number:
info = '{}\n{}: {}'.format(info, _('Card'),
person.card_number)
self.label_person_info.setText(info)
else:
self.label_person_info.setText(_('not found'))
self.tmp_person = person
def calculate_penalty(result):
assert isinstance(result, Result)
mode = race().get_setting('marked_route_mode', 'off')
if mode == 'off':
return
person = result.person
if person is None:
return
if person.group is None:
return
course = race().find_course(result)
if not course:
return
controls = course.controls
penalty = ResultChecker.penalty_calculation(result.splits,
controls,
check_existence=True)
if race().get_setting('marked_route_max_penalty_by_cp', False):
# limit the penalty by quantity of controls
penalty = min(len(controls), penalty)
if mode == 'laps':
result.penalty_laps = penalty
elif mode == 'time':
time_for_one_penalty = OTime(
msec=race().get_setting('marked_route_penalty_time', 60000))
result.penalty_time = time_for_one_penalty * penalty
def apply_changes_impl(self):
status_comment = StatusComments().remove_hint(
self.item_status_comment.currentText())
text = self.item_numbers.toPlainText()
numbers = []
for item in text.split('\n'):
if not len(item):
continue
for n_item in item.split():
if n_item.isdigit():
numbers.append(int(n_item))
old_numbers = []
obj = race()
for number in numbers:
if number not in old_numbers:
person = find(obj.persons, bib=number)
if person:
result = race().new_result(ResultManual)
result.person = person
result.status = ResultStatus.DID_NOT_START
result.status_comment = status_comment
Teamwork().send(result.to_dict())
obj.add_new_result(result)
else:
logging.info('{} not found'.format(number))
old_numbers.append(number)
def group_double_clicked(index):
try:
if index.row() < len(race().groups):
dialog = GroupEditDialog(race().groups[index.row()])
dialog.exec()
except Exception as e:
logging.error(str(e))
def apply_changes_impl(self):
org = self.current_object
assert (isinstance(org, Organization))
if self.is_new:
race().organizations.insert(0, org)
if org.name != self.item_name.text():
org.name = self.item_name.text()
if org.address.country.name != self.item_country.currentText():
org.address.country.name = self.item_country.currentText()
if org.address.state != self.item_region.currentText():
org.address.state = self.item_region.currentText()
if org.address.city != self.item_city.text():
org.address.city = self.item_city.text()
if org.address.street != self.item_address.text():
org.address.street = self.item_address.text()
if org.contact.value != self.item_contact.text():
org.contact.value = self.item_contact.text()
org.contact.name = 'phone'
GlobalAccess().get_main_window().refresh()
Teamwork().send(org.to_dict())
def execute(self):
result = race().new_result()
race().add_new_result(result)
Teamwork().send(result.to_dict())
logging.info('SPORTident result')
self.app.get_result_table().model().init_cache()
self.app.refresh()
def teamwork(self, command):
try:
race().update_data(command.data)
logging.info(repr(command.data))
self.refresh()
except Exception as e:
logging.error(str(e))
def apply_changes_impl(self):
obj = race()
start_date = self.item_start_date.dateTime().toPython()
end_date = self.item_end_date.dateTime().toPython()
obj.data.title = self.item_main_title.text()
obj.data.description = self.item_sub_title.toPlainText()
obj.data.description = obj.data.description.replace('\n', '<br>\n')
obj.data.location = self.item_location.text()
obj.data.url = self.item_url.text()
obj.data.chief_referee = self.item_refery.text()
obj.data.secretary = self.item_secretary.text()
obj.data.start_datetime = start_date
obj.data.end_datetime = end_date
t = RaceType.get_by_name(self.item_type.currentText())
if t is not None:
obj.data.race_type = t
obj.data.relay_leg_count = self.item_relay_legs.value()
obj.set_setting('system_zero_time',
(start_date.hour, start_date.minute, 0))
ResultCalculation(race()).process_results()
GlobalAccess().get_main_window().set_title()
def check_result(self, result):
if self.person is None:
return True
if self.person.group is None:
return True
if race().get_setting('result_processing_mode', 'time') == 'scores':
# process by score (rogain)
result.scores = self.calculate_scores_rogain(result)
return True
if race().get_setting('marked_route_dont_dsq', False):
# mode: competition without disqualification for mispunching (add penalty for missing cp)
return True
course = race().find_course(result)
if course is None:
if self.person.group.is_any_course:
return False
return True
if self.person.group.is_any_course:
return True
return result.check(course)
def __init__(self, result: ResultSportident):
assert result, Result
self._result = result
self._person = None
self.assign_chip_reading = race().get_setting('system_assign_chip_reading', 'off')
self.duplicate_chip_processing = race().get_setting('system_duplicate_chip_processing', 'several_results')
self.card_read_repeated = self.duplicate_chip_processing == 'bib_request'
def team_double_clicked(index):
try:
if index.row() < len(race().organizations):
dialog = OrganizationEditDialog(
race().organizations[index.row()])
dialog.exec()
except Exception as e:
logging.error(str(e))
def double_clicked(self, index):
try:
logging.debug('Clicked on ' + str(index.row()))
if index.row() < len(race().results):
dialog = ResultEditDialog(race().results[index.row()])
dialog.exec()
except Exception as e:
logging.error(str(e))
def group_double_clicked(index):
try:
if index.row() < len(race().groups):
dialog = GroupEditDialog(race().groups[index.row()])
dialog.exec_()
GlobalAccess().get_main_window().refresh()
except Exception as e:
logging.error(str(e))
def entry_double_clicked(index):
# show_edit_dialog(index)
try:
if index.row() < len(race().persons):
dialog = EntryEditDialog(race().persons[index.row()])
dialog.exec()
except Exception as e:
logging.error(str(e))
def execute(self):
logging.debug('Penalty removing start')
for result in race().results:
result.penalty_time = OTime(msec=0)
result.penalty_laps = 0
logging.debug('Penalty removing finish')
ResultCalculation(race()).process_results()
self.app.refresh()
def execute(self):
logging.debug('Penalty calculation start')
for result in race().results:
if result.person is not None:
ResultChecker.calculate_penalty(result)
logging.debug('Penalty calculation finish')
ResultCalculation(race()).process_results()
self.app.refresh()
def execute(self):
result = race().new_result(ResultManual)
Teamwork().send(result.to_dict())
race().add_new_result(result)
logging.info(_('Manual finish'))
self.app.get_result_table().model().init_cache()
self.app.refresh()
self.app.auto_save()
def _create_person(self):
new_person = Person()
new_person.bib = self._get_max_bib() + 1
new_person.surname = _('Competitor') + ' #' + str(new_person.bib)
new_person.group = self._find_group_by_punches()
self._result.person = new_person
race().persons.append(new_person)
def execute(self):
host = race().get_setting('teamwork_host', 'localhost')
port = race().get_setting('teamwork_port', 50010)
token = race().get_setting('teamwork_token', str(uuid.uuid4())[:8])
connection_type = race().get_setting('teamwork_type_connection', 'client')
Teamwork().set_options(host, port, token, connection_type)
Teamwork().toggle()
time.sleep(0.5)
self.app.interval()
def _find_group_by_punches(self):
for i in race().groups:
if i.course:
if self._result.check(i.course):
return i
if len(race().groups) > 0:
return race().groups[0]
return None
def double_clicked(self, index):
try:
logging.debug('Clicked on ' + str(index.row()))
if index.row() < len(race().results):
dialog = ResultEditDialog(race().results[index.row()])
dialog.exec_()
GlobalAccess().get_main_window().refresh()
# self.selectRow(index.row()+1)
except Exception as e:
logging.error(str(e))
def apply_changes_impl(self):
org = self.current_object
assert (isinstance(org, Organization))
if self.is_new:
race().organizations.insert(0, org)
org.name = self.item_name.text()
org.code = self.item_code.text()
org.country = self.item_country.currentText()
org.region = self.item_region.currentText()
org.contact = self.item_contact.text()
Teamwork().send(org.to_dict())
def teamwork(self, command):
try:
race().update_data(command.data)
logging.info(repr(command.data))
if 'object' in command.data and command.data['object'] in [
'ResultManual', 'ResultSportident', 'ResultSFR',
'ResultSportiduino'
]:
ResultCalculation(race()).process_results()
Broker().produce('teamwork_recieving', command.data)
self.refresh()
except Exception as e:
logging.error(str(e))
def get_data(person, result=None):
assert person, Person
data = {
'id': str(person.id),
'ref_id': str(person.id),
'bib': person.bib,
'group_name': person.group.name if person.group else '',
'name': person.full_name,
'organization':
person.organization.name if person.organization else '',
# 'country_code': 'RUS',
'card_number': person.card_number,
'national_code': None,
'world_code': None,
'out_of_competition': person.is_out_of_competition,
'start': person.start_time.to_sec() if person.start_time else 0
}
if race().is_relay():
# send relay fields only for relay events (requested by Ivan Churakoff)
data['relay_team'] = person.bib % 1000
data['lap'] = max(person.bib // 1000, 1)
if result is not None:
assert result, Result
data['start'] = result.get_start_time().to_sec()
data['result_ms'] = round(result.get_result_otime().to_msec() /
10) # 1/100 sec - proprietary format
data['result_status'] = str(result.status)
if len(result.splits):
data['splits'] = []
splits = race().get_course_splits(result)
for i in range(len(splits)):
"""
Orgeo Splits format:
Option Type Description
code string CP code
time int seconds of current split - time from previous CP to this CP
"""
current_split = {}
current_split['code'] = splits[i].code
end_time = splits[i].time
if i > 0:
start_time = splits[i - 1].time
else:
start_time = result.get_start_time()
current_split['time'] = (end_time - start_time).to_sec()
data['splits'].append(current_split)
return data
def check_name(self):
name = self.item_name.text()
self.button_ok.setDisabled(False)
if name and name != self.current_object.name:
org = find(race().organizations, name=name)
if org:
self.button_ok.setDisabled(True)
def get_options():
obj = race()
return BotOption(obj.get_setting('telegram_token', ''),
obj.get_setting('telegram_chat_id', ''),
obj.get_setting('telegram_template', ''),
obj.get_setting('telegram_parse_mode', ''),
obj.get_setting('telegram_enabled', False))
def set_values(self):
obj = race()
default_printer_name = QPrinter().printerName()
printer_name = Config().printer.get('main', default_printer_name)
# try:
# QPrinter().setPrinterName(printer_name)
# except Exception as e:
# printer_name = default_printer_name
self.selected_printer.setText(printer_name)
printer_name = Config().printer.get('split', default_printer_name)
# try:
# QPrinter().setPrinterName(printer_name)
# except Exception as e:
# logging.error(str(e))
# printer_name = default_printer_name
self.selected_split_printer.setText(printer_name)
self.print_splits_checkbox.setChecked(obj.get_setting('split_printout', False))
template = obj.get_setting('split_template')
if template:
self.item_template.setCurrentText(template)
self.item_margin_left.setValue(obj.get_setting('print_margin_left', 5.0))
self.item_margin_top.setValue(obj.get_setting('print_margin_top', 5.0))
self.item_margin_right.setValue(obj.get_setting('print_margin_right', 5.0))
self.item_margin_bottom.setValue(obj.get_setting('print_margin_bottom', 5.0))
def _has_result(self):
for result in race().results:
if result is None:
continue
if self._compare_result(result):
return True
return False
def _has_sportident_card(self):
for result in race().results:
if result is None:
continue
if result.card_number == self._result.card_number:
return True
return False
