def delete_einzelspiel(
delete_einzelspiel_modal_open: Union[None, int],
delete_einzelspiel_modal_close: Union[None, int],
delete_einzelspiel_modal_open_n_clicks: Dict,
delete_einzelspiel_modal_close_n_clicks: Dict,
delete_einzelspiel_modal: bool,
delete_einzelspiel_einzelspiel_id: Dict) -> Tuple[html.Div, html.Div, bool, Dict, Dict, Dict, Dict]:
delete_einzelspiel_modal_open = 0 if delete_einzelspiel_modal_open is None else delete_einzelspiel_modal_open
delete_einzelspiel_modal_close = 0 if delete_einzelspiel_modal_close is None else delete_einzelspiel_modal_close
if delete_einzelspiel_modal_open == 0 and delete_einzelspiel_modal_close == 0:
return html.Div(), html.Div(), delete_einzelspiel_modal, {'clicks': delete_einzelspiel_modal_open}, \
{'clicks': delete_einzelspiel_modal_close}, dict(), dict()
if delete_einzelspiel_modal_open > delete_einzelspiel_modal_open_n_clicks['clicks']:
einzelspiel_id = delete_einzelspiel_einzelspiel_id['id']
success = inactivate_einzelspiel_by_einzelspiel_id(einzelspiel_id)
if success:
header, body = html.Div(f'Spiel erfolgreich gelöscht.'), \
html.Div(wrap_alert([f'Spiel erfolgreich gelöscht.'], color='success', xl=12))
else:
header, body = html.Div(f'Spiel konnte nicht gelöscht werden.'), \
html.Div(wrap_alert([f'Spiel konnte nicht gelöscht werden. Bitte wenden Sie sich an den '
f'Administrator.'],
color='danger', xl=12))
close_button, close_button_reload = dict(display='none'), dict()
elif delete_einzelspiel_modal_close > delete_einzelspiel_modal_close_n_clicks['clicks']:
header, body = html.Div(), html.Div()
close_button, close_button_reload = dict(), dict()
else:
header, body = html.Div(), html.Div()
close_button, close_button_reload = dict(), dict()
return header, body, not delete_einzelspiel_modal, {'clicks': delete_einzelspiel_modal_open}, \
{'clicks': delete_einzelspiel_modal_close}, close_button, close_button_reload
def create_runde(
create_runde_modal_open: Union[None, int],
create_runde_modal_close: Union[None, int],
create_runde_modal_open_n_clicks: Dict,
create_runde_modal_close_n_clicks: Dict,
create_runde_modal: bool,
runde_new_name: Union[None, str],
runde_new_ort: Union[None, str],
runde_new_date: Union[None, str]) -> Tuple[html.Div, html.Div, bool, Dict, Dict, Dict, Dict]:
create_runde_modal_open = 0 if create_runde_modal_open is None else create_runde_modal_open
create_runde_modal_close = 0 if create_runde_modal_close is None else create_runde_modal_close
if create_runde_modal_open == 0 and create_runde_modal_close == 0:
return html.Div(), html.Div(), create_runde_modal, {'clicks': create_runde_modal_open}, \
{'clicks': create_runde_modal_close}, dict(), dict()
if create_runde_modal_open > create_runde_modal_open_n_clicks['clicks']:
runde_id, msgs = insert_runde(datum=runde_new_date, name=runde_new_name, ort=runde_new_ort)
if runde_id is not None:
runde = get_runde_by_id(runde_id)
runde_string = f'{runde.datum.strftime("%d. %b %Y")} - {runde.name} - {runde.ort}'
header, body = html.Div(f'Runde wurde erfolgreich angelegt'), \
html.Div(wrap_alert([f'Runde "{runde_string}" erfolgreich angelegt.'],
color='success', xl=12))
close_button, close_button_reload = dict(display='none'), dict()
else:
header, body = html.Div('Runde wurde nicht angelegt'), html.Div(
wrap_alert(msgs, color='danger', xl=12))
close_button, close_button_reload = dict(), dict(display='none'),
elif create_runde_modal_close > create_runde_modal_close_n_clicks['clicks']:
header, body = html.Div(), html.Div()
close_button, close_button_reload = dict(), dict()
else:
header, body = html.Div(), html.Div()
close_button, close_button_reload = dict(), dict()
return header, body, not create_runde_modal, {'clicks': create_runde_modal_open}, \
{'clicks': create_runde_modal_close}, close_button, close_button_reload
def create_teilnehmer(
create_teilnehmer_modal_open: Union[None, int],
create_teilnehmer_modal_close: Union[None, int],
create_teilnehmer_modal_open_n_clicks: Dict,
create_teilnehmer_modal_close_n_clicks: Dict,
create_teilnehmer_modal: bool,
teilnehmer_vorname: Union[None, str],
teilnehmer_nachname: Union[None, str]) -> Tuple[html.Div, html.Div, bool, Dict, Dict, Dict, Dict]:
create_teilnehmer_modal_open = 0 if create_teilnehmer_modal_open is None else create_teilnehmer_modal_open
create_teilnehmer_modal_close = 0 if create_teilnehmer_modal_close is None else create_teilnehmer_modal_close
if create_teilnehmer_modal_open == 0 and create_teilnehmer_modal_close == 0:
return html.Div(), html.Div(), create_teilnehmer_modal, {'clicks': create_teilnehmer_modal_open}, \
{'clicks': create_teilnehmer_modal_close}, dict(), dict()
if create_teilnehmer_modal_open > create_teilnehmer_modal_open_n_clicks['clicks']:
teilnehmer_id, msgs = insert_teilnehmer(vorname=teilnehmer_vorname, nachname=teilnehmer_nachname)
if teilnehmer_id is not None:
teilnehmer = get_teilnehmer_by_id(teilnehmer_id)
header, body = html.Div('Teilnehmer wurde erfolgreich angelegt'), \
html.Div(wrap_alert([f'{teilnehmer.nachname}, {teilnehmer.vorname} erfolgreich angelegt.'],
color='success', xl=12))
close_button, close_button_reload = dict(display='none'), dict()
else:
header, body = html.Div('Teilnehmer wurde nicht angelegt'), html.Div(
wrap_alert(msgs, color='danger', xl=12))
close_button, close_button_reload = dict(), dict(display='none')
elif create_teilnehmer_modal_close > create_teilnehmer_modal_close_n_clicks['clicks']:
header, body = html.Div(), html.Div()
close_button, close_button_reload = dict(), dict()
else:
header, body = html.Div(), html.Div()
close_button, close_button_reload = dict(), dict()
return header, body, not create_teilnehmer_modal, {'clicks': create_teilnehmer_modal_open}, \
{'clicks': create_teilnehmer_modal_close}, close_button, close_button_reload
def calculate_solo(
solo_spielstand_eintragen_button_n_clicks: int,
solo_ansager_id: Union[None, int],
solo_spielart: Union[None, str],
solo_kontriert_id: List[int],
solo_re_id: List[int],
solo_farbe: List[str],
solo_tout: List[int],
solo_laufende: Union[None, int],
solo_spieler_nichtspieler_augen: Union[None, int],
solo_augen: Union[None, int],
solo_schwarz: Union[None, int],
runde_id: Union[None, str],
geber_id: Union[None, str],
ausspieler_id: Union[None, str],
mittelhand_id: Union[None, str],
hinterhand_id: Union[None, str],
geberhand_id: Union[None, str],
gelegt_ausspieler_id: List[int],
gelegt_mittelhand_id: List[int],
gelegt_hinterhand_id: List[int],
gelegt_geberhand_id: List[int]) -> Tuple[Union[None, dbc.Row], Dict, html.Div, html.Div, bool]:
teilnehmer_ids = [ausspieler_id, mittelhand_id, hinterhand_id, geberhand_id]
if _validate_teilnehmer(runde_id, geber_id, teilnehmer_ids) is not None:
return None, dict(), html.Div(), html.Div(), False
gelegt_ids = _get_gelegt_ids(ausspieler_id, mittelhand_id, hinterhand_id, geberhand_id, gelegt_ausspieler_id,
gelegt_mittelhand_id, gelegt_hinterhand_id, gelegt_geberhand_id)
raw_config = SoloRawConfig(runde_id=int(runde_id),
geber_id=geber_id,
teilnehmer_ids=[int(t) for t in teilnehmer_ids],
gelegt_ids=gelegt_ids,
ansager_id=solo_ansager_id,
spielart=solo_spielart,
kontriert_id=solo_kontriert_id,
re_id=solo_re_id,
farbe=solo_farbe,
tout=solo_tout,
laufende=solo_laufende,
spieler_nichtspieler_augen=solo_spieler_nichtspieler_augen,
augen=solo_augen,
schwarz=solo_schwarz)
solo_validator = SoloValidator(raw_config)
messages = solo_validator.validation_messages
if len(messages) > 0:
return wrap_alert(messages), dict(display='none'), html.Div(), html.Div(), False
solo_calculator = SoloCalculator(solo_validator.validated_config)
result = SoloPresenter(solo_calculator).get_result()
if solo_spielstand_eintragen_button_n_clicks is not None and solo_spielstand_eintragen_button_n_clicks >= 1:
SoloWriter(solo_calculator).write()
header, body = wrap_stats_by_runde_ids([runde_id])
return result, dict(), header, body, True
else:
return result, dict(), html.Div(), html.Div(), False
def calculate_rufspiel(
rufspiel_spielstand_eintragen_button_n_clicks: int,
rufspiel_ansager_id: Union[None, int],
rufspiel_rufsau: Union[None, str],
rufspiel_kontriert_id: List[int],
rufspiel_re_id: List[int],
rufspiel_partner_id: Union[None, int],
rufspiel_laufende: Union[None, int],
rufspiel_spieler_nichtspieler_augen: Union[None, int],
rufspiel_augen: Union[None, int],
rufspiel_schwarz: Union[None, int],
runde_id: Union[None, str],
geber_id: Union[None, str],
ausspieler_id: Union[None, str],
mittelhand_id: Union[None, str],
hinterhand_id: Union[None, str],
geberhand_id: Union[None, str],
gelegt_ausspieler_id: List[int],
gelegt_mittelhand_id: List[int],
gelegt_hinterhand_id: List[int],
gelegt_geberhand_id: List[int]) -> Tuple[Union[None, dbc.Row], Dict, html.Div, html.Div, bool]:
teilnehmer_ids = [ausspieler_id, mittelhand_id, hinterhand_id, geberhand_id]
if _validate_teilnehmer(runde_id, geber_id, teilnehmer_ids) is not None:
return None, dict(), html.Div(), html.Div(), False
gelegt_ids = _get_gelegt_ids(ausspieler_id, mittelhand_id, hinterhand_id, geberhand_id, gelegt_ausspieler_id,
gelegt_mittelhand_id, gelegt_hinterhand_id, gelegt_geberhand_id)
raw_config = RufspielRawConfig(runde_id=int(runde_id),
geber_id=geber_id,
teilnehmer_ids=[int(t) for t in teilnehmer_ids],
gelegt_ids=gelegt_ids,
ansager_id=rufspiel_ansager_id,
rufsau=rufspiel_rufsau,
kontriert_id=rufspiel_kontriert_id,
re_id=rufspiel_re_id,
partner_id=rufspiel_partner_id,
laufende=rufspiel_laufende,
spieler_nichtspieler_augen=rufspiel_spieler_nichtspieler_augen,
augen=rufspiel_augen,
schwarz=rufspiel_schwarz)
rufspiel_validator = RufspielValidator(raw_config)
messages = rufspiel_validator.validation_messages
if len(messages) > 0:
return wrap_alert(messages), dict(display='none'), html.Div(), html.Div(), False
rufspiel_calculator = RufspielCalculator(rufspiel_validator.validated_config)
result = RufspielPresenter(rufspiel_calculator).get_result()
if rufspiel_spielstand_eintragen_button_n_clicks is not None and rufspiel_spielstand_eintragen_button_n_clicks >= 1:
RufspielWriter(rufspiel_calculator).write()
header, body = wrap_stats_by_runde_ids([runde_id])
return result, dict(), header, body, True
else:
return result, dict(), html.Div(), html.Div(), False
def calculate_ramsch(
ramsch_spielstand_eintragen_button_n_clicks: int,
ramsch_jungfrau_ids: List[int],
ramsch_ausspieler_augen: Union[None, int],
ramsch_mittelhand_augen: Union[None, int],
ramsch_hinterhand_augen: Union[None, int],
ramsch_geberhand_augen: Union[None, int],
ramsch_manuelle_verlierer_ids: List[int],
runde_id: Union[None, str],
geber_id: Union[None, str],
ausspieler_id: Union[None, str],
mittelhand_id: Union[None, str],
hinterhand_id: Union[None, str],
geberhand_id: Union[None, str],
gelegt_ausspieler_id: List[int],
gelegt_mittelhand_id: List[int],
gelegt_hinterhand_id: List[int],
gelegt_geberhand_id: List[int]) -> Tuple[Union[None, dbc.Row], Dict, html.Div, html.Div, bool]:
teilnehmer_ids = [ausspieler_id, mittelhand_id, hinterhand_id, geberhand_id]
if _validate_teilnehmer(runde_id, geber_id, teilnehmer_ids) is not None:
return None, dict(), html.Div(), html.Div(), False
gelegt_ids = _get_gelegt_ids(ausspieler_id, mittelhand_id, hinterhand_id, geberhand_id, gelegt_ausspieler_id,
gelegt_mittelhand_id, gelegt_hinterhand_id, gelegt_geberhand_id)
raw_config = RamschRawConfig(runde_id=int(runde_id),
geber_id=geber_id,
teilnehmer_ids=[int(t) for t in teilnehmer_ids],
gelegt_ids=gelegt_ids,
jungfrau_ids=ramsch_jungfrau_ids,
ausspieler_augen=ramsch_ausspieler_augen,
mittelhand_augen=ramsch_mittelhand_augen,
hinterhand_augen=ramsch_hinterhand_augen,
geberhand_augen=ramsch_geberhand_augen,
manuelle_verlierer_ids=ramsch_manuelle_verlierer_ids)
ramsch_validator = RamschValidator(raw_config)
messages = ramsch_validator.validation_messages
if len(messages) > 0:
return wrap_alert(messages), dict(display='none'), html.Div(), html.Div(), False
ramsch_calculator = RamschCalculator(ramsch_validator.validated_config)
result = RamschPresenter(ramsch_calculator).get_result()
if ramsch_spielstand_eintragen_button_n_clicks is not None and ramsch_spielstand_eintragen_button_n_clicks >= 1:
RamschWriter(ramsch_calculator).write()
header, body = wrap_stats_by_runde_ids([runde_id])
return result, dict(), header, body, True
else:
return result, dict(), html.Div(), html.Div(), False
def _validate_teilnehmer(runde_id: Union[None, str], geber_id: Union[None, str],
teilnehmer_ids: List[str]) -> Union[html.Div, None]:
m = []
if runde_id is None:
m.append(f'Bitte wählen Sie eine Runde.')
if geber_id is None:
m.append(f'Bitte wählen einen Geber.')
if None in teilnehmer_ids:
m.append(f'Bitte wählen Sie vier Teilnehmer.')
teilnehmer_ids_without_none = [int(t) for t in teilnehmer_ids if t is not None]
if len(teilnehmer_ids_without_none) != len(set(teilnehmer_ids_without_none)):
m.append(f'Bitte wählen Sie eindeutige Teilnehmer.')
teilnehmer_ids_without_none_and_geberhand = [int(t) for t in teilnehmer_ids[:-1] if t is not None]
if geber_id is not None and int(geber_id) in teilnehmer_ids_without_none_and_geberhand:
m.append(f'Bitte positionieren Sie den Geber eindeutig auf die Geberhand.')
if len(m) == 0:
return None
return html.Div([wrap_empty_dbc_row(), wrap_alert(m)])
def wrap_letztes_spiel_loeschen_layout():
current = pathlib.Path(__file__).name.split('.')[0]
einzelspiel_id = get_latest_einzelspiel_id()
if einzelspiel_id is not None:
einzelspiel = get_einzelspiele_by_einzelspiel_ids([einzelspiel_id])[0]
runde = get_runde_by_id(einzelspiel.runde_id)
df = get_latest_result()
dict = {
entry['teilnehmer_id']: entry['punkte']
for entry in df.to_dict(orient='records')
}
tt = f"{einzelspiel.created_on.strftime('%d.%m.%Y')} - {einzelspiel.created_on.strftime('%H:%M:%S')}"
return html.Div([
dcc.Store(id='delete_einzelspiel_modal_open_n_clicks',
data={'n_clicks': 0}),
dcc.Store(id='delete_einzelspiel_modal_close_n_clicks',
data={'n_clicks': 0}),
dcc.Store(id='delete_einzelspiel_einzelspiel_id',
data={'id': einzelspiel_id}),
dbc.Modal([
dbc.ModalHeader(id='delete_einzelspiel_modal_header'),
dbc.ModalBody(html.Div(id='delete_einzelspiel_modal_body')),
dbc.ModalFooter([
dbc.Button('Schließen',
id='delete_einzelspiel_modal_close',
color='primary',
block=True),
dbc.Button('Schließen',
id='delete_einzelspiel_modal_close_reload',
color='primary',
block=True,
href=f'/{current}',
external_link=True)
]),
],
id='delete_einzelspiel_modal',
size='xl',
scrollable=True),
dbc.Container([
wrap_empty_dbc_row(),
dbc.Row([
dbc.Col([
dbc.ListGroup([
dbc.ListGroupItem(f'{runde.name}'),
dbc.ListGroupItem(tt),
dbc.ListGroupItem(
f'{einzelspiel.spielart.capitalize()}'),
])
],
xl=6,
xs=12),
]),
wrap_empty_dbc_row(),
Presenter.get_result_message(dict, row_wise=True),
wrap_empty_dbc_row(),
dbc.Row([
dbc.Col([
dbc.FormGroup([
dbc.Button('Spiel löschen',
id='delete_einzelspiel_modal_open',
color='primary',
block=True),
])
],
xl=6,
xs=12)
]),
wrap_footer_row()
]),
])
else:
return html.Div([
dbc.Container([
wrap_empty_dbc_row(),
wrap_alert(['Bisher wurden keine Spiele gespielt.']),
wrap_footer_row()
])
])
