def __init__(self, parent):
self.widget = QWidget()
self.layout = QFormLayout(parent)
self.sounds = get_sounds()
self.item_enabled = QCheckBox(_('Enabled'))
self.item_enabled.setChecked(Config().sound.get('enabled'))
self.layout.addRow(self.item_enabled)
self.label_successful = QLabel(_('Successful result'))
self.item_successful = AdvComboBox()
self.item_successful.addItems(self.sounds)
self.item_successful.setCurrentText(Config().sound.get('successful')
or config.sound_dir('ok.wav'))
self.layout.addRow(self.label_successful, self.item_successful)
self.label_unsuccessful = QLabel(_('Unsuccessful result'))
self.item_unsuccessful = AdvComboBox()
self.item_unsuccessful.addItems(self.sounds)
self.item_unsuccessful.setCurrentText(
Config().sound.get('unsuccessful')
or config.sound_dir('failure.wav'))
self.layout.addRow(self.label_unsuccessful, self.item_unsuccessful)
self.widget.setLayout(self.layout)
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 save(self):
Config().sound.set('enabled', self.item_enabled.isChecked())
Config().sound.set('successful', self.item_successful.currentText())
Config().sound.set('unsuccessful',
self.item_unsuccessful.currentText())
Config().sound.set('enabled_rented_card',
self.item_enabled_rented_card.isChecked())
Config().sound.set('rented_card', self.item_rented_card.currentText())
def apply_changes_impl(self):
obj = race()
main_printer = self.selected_printer.text()
Config().printer.set('main', main_printer)
split_printer = self.selected_split_printer.text()
Config().printer.set('split', split_printer)
obj.set_setting('split_printout', self.print_splits_checkbox.isChecked())
obj.set_setting('split_template', self.item_template.currentText())
obj.set_setting('print_margin_left', self.item_margin_left.value())
obj.set_setting('print_margin_top', self.item_margin_top.value())
obj.set_setting('print_margin_right', self.item_margin_right.value())
obj.set_setting('print_margin_bottom', self.item_margin_bottom.value())
def split_printout(result):
person = result.person
if not person or not person.group:
raise NoResultToPrintException('No results to print')
obj = race()
course = obj.find_course(result)
if person.group and course:
printer = Config().printer.get('split')
template_path = obj.get_setting(
'split_template', template_dir('split', '1_split_printout.html'))
s = GroupSplits(obj, person.group).generate(True)
result.check_who_can_win()
if not str(template_path).endswith('.html') and platform.system(
) == 'Windows':
# Internal split printout, pure python. Works faster, than jinja2 template + pdf
size = 60 # base scale factor is 60, used win32con.MM_TWIPS MapMode (unit = 1/20 of dot, 72dpi)
array = str(template_path).split(_('scale') + '=')
if len(array) > 1:
scale = array[1]
if scale.isdecimal():
size = int(scale) * size // 100
pr = SportorgPrinter(
printer, size, int(obj.get_setting('print_margin_left', 5.0)),
int(obj.get_setting('print_margin_top', 5.0)))
pr.print_split(result)
pr.end_doc()
return
organization = person.organization
if not organization:
organization = Organization()
template = get_text_from_file(template_path,
race=obj.to_dict(),
person=person.to_dict(),
result=result.to_dict(),
group=person.group.to_dict(),
course=course.to_dict(),
organization=organization.to_dict(),
items=s.to_dict())
if not printer:
raise NoPrinterSelectedException('No printer selected')
print_html(
printer,
template,
obj.get_setting('print_margin_left', 5.0),
obj.get_setting('print_margin_top', 5.0),
obj.get_setting('print_margin_right', 5.0),
obj.get_setting('print_margin_bottom', 5.0),
)
def get_group_rank(self, group):
"""
Rank calculation, takes sums or scores from qualification of best X (default=10) athletes, who have OK result
and are not out of competition
:param group:
:return: rank of group, -1 if we have < X (default=5) successfull results
"""
scores = []
array = self.get_group_finishes(group)
start_limit = Config().ranking.get('start_limit', 10)
finish_limit = Config().ranking.get('finish_limit', 5)
sum_count = Config().ranking.get('sum_count', 10)
if len(array) < start_limit:
# less than X (default=10) started
return -1
for i in array:
assert isinstance(i, Result)
if i.is_status_ok():
person = i.person
if not person.is_out_of_competition:
qual = person.qual
scores.append(qual.get_score())
if len(scores) < finish_limit:
# less than X (default=5) finished and not disqualified
return -1
if len(scores) <= sum_count:
# get rank sum of X (default=10) best finished
return sum(scores)
scores = sorted(scores)
return sum(scores[-sum_count:])
def save(self):
Config().configuration.set('current_locale',
self.item_lang.currentText())
Config().configuration.set('show_toolbar',
self.item_show_toolbar.isChecked())
Config().configuration.set('autosave', self.item_auto_save.isChecked())
Config().configuration.set('open_recent_file',
self.item_open_recent_file.isChecked())
Config().configuration.set('use_birthday',
self.item_use_birthday.isChecked())
Config().configuration.set('check_updates',
self.item_check_updates.isChecked())
def set_values_from_model(self):
self.item_surname.setText(self.current_object.surname)
self.item_surname.selectAll()
self.item_name.setCurrentText(self.current_object.name)
if self.current_object.group is not None:
self.item_group.setCurrentText(self.current_object.group.name)
else:
self.item_group.setCurrentText(self.GROUP_NAME)
if self.current_object.organization is not None:
self.item_team.setCurrentText(
self.current_object.organization.name)
else:
self.item_team.setCurrentText(self.ORGANIZATION_NAME)
if self.current_object.qual:
self.item_qual.setCurrentText(self.current_object.qual.get_title())
if self.current_object.bib:
self.item_bib.setValue(int(self.current_object.bib))
if self.current_object.start_time is not None:
time = time_to_qtime(self.current_object.start_time)
self.item_start.setTime(time)
if self.current_object.start_group is not None:
self.item_start_group.setValue(int(
self.current_object.start_group))
if self.current_object.card_number:
self.item_card.setValue(self.current_object.card_number)
self.item_out_of_competition.setChecked(
self.current_object.is_out_of_competition)
self.item_paid.setChecked(self.current_object.is_paid)
self.item_paid.setChecked(self.current_object.is_paid)
self.item_personal.setChecked(self.current_object.is_personal)
self.item_rented.setChecked(self.current_object.is_rented_card)
self.item_comment.setText(self.current_object.comment)
use_birthday = Config().configuration.get('use_birthday', False)
if use_birthday:
if self.current_object.birth_date:
self.item_birthday.setDate(self.current_object.birth_date)
else:
if self.current_object.get_year():
self.item_year.setValue(self.current_object.get_year())
def split_printout(result):
person = result.person
if not person or not person.group:
raise NoResultToPrintException('No results to print')
obj = race()
course = obj.find_course(result)
if person.group and course:
printer = Config().printer.get('split')
template_path = obj.get_setting(
'split_template', template_dir('split', 'split_printout.html'))
organization = person.organization
if not organization:
organization = Organization()
s = GroupSplits(obj, person.group).generate(True)
template = get_text_from_file(template_path,
race=obj.to_dict(),
person=person.to_dict(),
result=result.to_dict(),
group=person.group.to_dict(),
course=course.to_dict(),
organization=organization.to_dict(),
items=s.to_dict())
if not printer:
raise NoPrinterSelectedException('No printer selected')
print_html(
printer,
template,
obj.get_setting('print_margin_left', 5.0),
obj.get_setting('print_margin_top', 5.0),
obj.get_setting('print_margin_right', 5.0),
obj.get_setting('print_margin_bottom', 5.0),
)
def __init__(self, parent):
self.widget = QWidget()
self.layout = QFormLayout(parent)
self.label_lang = QLabel(_('Languages'))
self.item_lang = AdvComboBox()
self.item_lang.addItems(get_languages())
self.item_lang.setCurrentText(Config().configuration.get(
'current_locale', 'ru_RU'))
self.layout.addRow(self.label_lang, self.item_lang)
self.item_auto_save = QSpinBox()
self.item_auto_save.setMaximum(3600 * 24)
self.item_auto_save.setValue(
Config().configuration.get('autosave_interval'))
self.layout.addRow(_('Auto save') + ' (sec)', self.item_auto_save)
self.item_show_toolbar = QCheckBox(_('Show toolbar'))
self.item_show_toolbar.setChecked(
Config().configuration.get('show_toolbar'))
self.layout.addRow(self.item_show_toolbar)
self.item_open_recent_file = QCheckBox(_('Open recent file'))
self.item_open_recent_file.setChecked(
Config().configuration.get('open_recent_file'))
self.layout.addRow(self.item_open_recent_file)
self.item_use_birthday = QCheckBox(_('Use birthday'))
self.item_use_birthday.setChecked(
Config().configuration.get('use_birthday'))
self.layout.addRow(self.item_use_birthday)
self.item_check_updates = QCheckBox(_('Check updates'))
self.item_check_updates.setChecked(
Config().configuration.get('check_updates'))
# self.layout.addRow(self.item_check_updates)
self.widget.setLayout(self.layout)
def is_enabled():
return Config().sound.get('enabled')
def _play(self, name):
sound = Config().sound.get(name)
if self.is_enabled() and sound:
Audio().play(sound)
def is_enabled_rented_card():
return Config().sound.get('enabled_rented_card')
def get_conf():
return Config().parser
def get_group_rank_relay(self, group):
"""
Rank calculation, takes sums or scores from qualification of best X (default=10) athletes, who have OK result
and are not out of competition
:param group:
:return: rank of group, -1 if we have < X (default=4) successfull teams
"""
teams = find(self.race.relay_teams, group=group, return_all=True)
success_teams = []
start_limit = Config().ranking.get('start_limit_relay', 6)
finish_limit = Config().ranking.get('finish_limit_relay', 4)
sum_count = Config().ranking.get('sum_count_relay', 10)
relay_ranking_method = Config().ranking.get('relay_ranking_method',
'personal')
started_teams = 0
if teams:
for cur_team in teams:
assert isinstance(cur_team, RelayTeam)
if cur_team.get_is_out_of_competition():
continue
if not cur_team.get_is_all_legs_finished():
continue
started_teams += 1
if cur_team.get_is_status_ok():
success_teams.append(cur_team)
if started_teams < start_limit:
# less than X (default=6) teams started in relay
return -1
if len(success_teams) < finish_limit:
# less than X (default=4) teams successfully finished in relay
return -1
if relay_ranking_method == 'personal':
scores = []
for cur_team in success_teams:
for cur_leg in cur_team.legs:
res = cur_leg.get_result()
person = res.person
qual = person.qual
scores.append(qual.get_score())
if len(scores) <= sum_count:
# get rank sum of X (default=10) best finished
return sum(scores)
scores = sorted(scores)
return sum(scores[-sum_count:])
else:
# calculate average team score and get sum of first X teams
average_sum = 0
for cur_team in success_teams[:sum_count]:
team_sum = 0
for cur_leg in cur_team.legs:
res = cur_leg.get_result()
person = res.person
qual = person.qual
team_sum += qual.get_score()
average_sum += team_sum / len(cur_team.legs)
return average_sum
def apply_changes_impl(self):
for tab, _ in self.widgets:
tab.save()
Config().save()
def init_ui(self):
self.setWindowTitle(_('Entry properties'))
self.setWindowIcon(QIcon(config.ICON))
self.setSizeGripEnabled(False)
self.setModal(True)
self.layout = QFormLayout(self)
self.label_surname = QLabel(_('Last name'))
self.item_surname = QLineEdit()
self.layout.addRow(self.label_surname, self.item_surname)
self.label_name = QLabel(_('First name'))
self.item_name = AdvComboBox()
self.item_name.addItems(get_names())
self.layout.addRow(self.label_name, self.item_name)
self.label_group = QLabel(_('Group'))
self.item_group = AdvComboBox()
self.item_group.addItems(get_race_groups())
self.layout.addRow(self.label_group, self.item_group)
self.label_team = QLabel(_('Team'))
self.item_team = AdvComboBox()
self.item_team.addItems(get_race_teams())
self.layout.addRow(self.label_team, self.item_team)
use_birthday = Config().configuration.get('use_birthday', False)
if use_birthday:
self.label_birthday = QLabel(_('Birthday'))
self.item_birthday = QDateEdit()
self.item_birthday.setDate(date.today())
self.item_birthday.setMaximumDate(date.today())
self.layout.addRow(self.label_birthday, self.item_birthday)
else:
self.label_year = QLabel(_('Year of birth'))
self.item_year = QSpinBox()
self.item_year.setMinimum(0)
self.item_year.setMaximum(date.today().year)
self.item_year.editingFinished.connect(self.year_change)
self.layout.addRow(self.label_year, self.item_year)
self.label_qual = QLabel(_('Qualification'))
self.item_qual = AdvComboBox()
for i in list(Qualification):
self.item_qual.addItem(i.get_title())
self.layout.addRow(self.label_qual, self.item_qual)
self.is_ok['bib'] = True
self.label_bib = QLabel(_('Bib'))
self.item_bib = QSpinBox()
self.item_bib.setMinimum(0)
self.item_bib.setMaximum(Limit.BIB)
self.item_bib.valueChanged.connect(self.check_bib)
self.layout.addRow(self.label_bib, self.item_bib)
self.label_bib_info = QLabel('')
self.layout.addRow(QLabel(''), self.label_bib_info)
self.label_start = QLabel(_('Start time'))
self.item_start = QTimeEdit()
self.item_start.setDisplayFormat(self.time_format)
self.layout.addRow(self.label_start, self.item_start)
self.label_start_group = QLabel(_('Start group'))
self.item_start_group = QSpinBox()
self.item_start_group.setMinimum(0)
self.item_start_group.setMaximum(99)
self.layout.addRow(self.label_start_group, self.item_start_group)
self.is_ok['card'] = True
self.label_card = QLabel(_('Punch card #'))
self.item_card = QSpinBox()
self.item_card.setMinimum(0)
self.item_card.setMaximum(9999999)
self.item_card.valueChanged.connect(self.check_card)
self.layout.addRow(self.label_card, self.item_card)
self.label_card_info = QLabel('')
self.layout.addRow(QLabel(''), self.label_card_info)
self.item_rented = QCheckBox(_('rented card'))
self.item_paid = QCheckBox(_('is paid'))
self.item_out_of_competition = QCheckBox(_('out of competition'))
self.item_personal = QCheckBox(_('personal participation'))
self.layout.addRow(self.item_rented, self.item_out_of_competition)
self.layout.addRow(self.item_paid, self.item_personal)
self.label_comment = QLabel(_('Comment'))
self.item_comment = QTextEdit()
self.item_comment.setTabChangesFocus(True)
self.layout.addRow(self.label_comment, self.item_comment)
def cancel_changes():
self.close()
def apply_changes():
try:
self.apply_changes_impl()
except Exception as e:
logging.error(str(e))
self.close()
button_box = QDialogButtonBox(QDialogButtonBox.Ok
| QDialogButtonBox.Cancel)
self.button_ok = button_box.button(QDialogButtonBox.Ok)
self.button_ok.setText(_('OK'))
self.button_ok.clicked.connect(apply_changes)
self.button_cancel = button_box.button(QDialogButtonBox.Cancel)
self.button_cancel.setText(_('Cancel'))
self.button_cancel.clicked.connect(cancel_changes)
self.layout.addRow(button_box)
self.show()
def apply_changes_impl(self):
person = self.current_object
assert (isinstance(person, Person))
if self.is_new:
race().persons.insert(0, person)
if person.name != self.item_name.currentText():
person.name = self.item_name.currentText()
if person.surname != self.item_surname.text():
person.surname = self.item_surname.text()
if (person.group is not None and person.group.name != self.item_group.currentText()) or\
(person.group is None and len(self.item_group.currentText()) > 0):
person.group = find(race().groups,
name=self.item_group.currentText())
if (person.organization is not None and person.organization.name != self.item_team.currentText()) or \
(person.organization is None and len(self.item_team.currentText()) > 0):
organization = find(race().organizations,
name=self.item_team.currentText())
if organization is None:
organization = Organization()
organization.name = self.item_team.currentText()
race().organizations.append(organization)
Teamwork().send(organization.to_dict())
person.organization = organization
if person.qual.get_title() != self.item_qual.currentText():
person.qual = Qualification.get_qual_by_name(
self.item_qual.currentText())
if person.bib != self.item_bib.value():
person.bib = self.item_bib.value()
new_time = time_to_otime(self.item_start.time())
if person.start_time != new_time:
person.start_time = new_time
if person.start_group != self.item_start_group.value(
) and self.item_start_group.value():
person.start_group = self.item_start_group.value()
if (not person.card_number or int(person.card_number) != self.item_card.value()) \
and self.item_card.value:
race().person_card_number(person, self.item_card.value())
if person.is_out_of_competition != self.item_out_of_competition.isChecked(
):
person.is_out_of_competition = self.item_out_of_competition.isChecked(
)
if person.is_paid != self.item_paid.isChecked():
person.is_paid = self.item_paid.isChecked()
if person.is_rented_card != self.item_rented.isChecked():
person.is_rented_card = self.item_rented.isChecked()
if person.is_personal != self.item_personal.isChecked():
person.is_personal = self.item_personal.isChecked()
if person.comment != self.item_comment.toPlainText():
person.comment = self.item_comment.toPlainText()
use_birthday = Config().configuration.get('use_birthday', False)
if use_birthday:
new_birthday = qdate_to_date(self.item_birthday.date())
if person.birth_date != new_birthday and new_birthday:
if person.birth_date or new_birthday != date.today():
person.birth_date = new_birthday
else:
if person.get_year() != self.item_year.value():
person.set_year(self.item_year.value())
ResultCalculation(race()).process_results()
Teamwork().send(person.to_dict())
