summaryrefslogtreecommitdiff
path: root/ql/lineup.py
blob: cca69e5c3d1706285633d111d296b0d090703f45 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
# -*- coding: utf-8 -*-
from cached_property import cached_property
from .orm.models import Segment, Team, Player


class TeamInSegment(object):

    OPEN_NS = 'open NS'
    OPEN_EW = 'open EW'
    CLOSED_NS = 'closed NS'
    CLOSED_EW = 'closed EW'

    def __init__(self, team, segment):
        self.team = team
        self.segment = segment

    def get_paired_players_fields(self):
        raise NotImplementedError()

    @property
    def name(self):
        return self.team.name

    @property
    def players(self):
        return self.team.players

    @property
    def pairs(self):
        for players_fields_entity in self.get_paired_players_fields():
            yield Pair(self, players_fields_entity['fields'], players_fields_entity['label'])

    @property
    def player_names(self):
        return [ '%s %s' % (p.last_name, p.first_name) for p in self.team.players.order_by('last_name', 'first_name').all() ]


class HomeTeamInSegment(TeamInSegment):

    def __init__(self, *args, **kwargs):
        super(HomeTeamInSegment, self).__init__(*args, **kwargs)

    def get_paired_players_fields(self):
        return [
            {
                'fields': ['openN', 'openS'],
                'label': self.OPEN_NS,
            },
            {
                'fields': [ 'closeE', 'closeW' ],
                'label': self.CLOSED_EW,
            },
        ]


class AwayTeamInSegment(TeamInSegment):

    def __init__(self, *args, **kwargs):
        super(AwayTeamInSegment, self).__init__(*args, **kwargs)

    def get_paired_players_fields(self):
        return [
            {
                'fields': ['openE', 'openW' ],
                'label': self.OPEN_EW,
            },
            {
                'fields': [ 'closeN', 'closeS' ],
                'label': self.CLOSED_NS,
            },
        ]


class Pair(object):

    def __init__(self, team, players_fields, label):
        assert len(players_fields) == 2
        self.team = team
        self.players_fields = players_fields
        self.label = label
        self.last_changed_player_num = None

    @property
    def players(self):
        return [ self._load_player(field) for field in self.players_fields ]

    def _load_player(self, player_field):
        try:
            return getattr(self.team.segment, player_field)
        except Player.DoesNotExist:
            return None

    @property
    def info(self):
        return 'Team: %s - %s - %s' % (
            self.team.name,
            self.label,
            [ p.info if p is not None else '<blank>' for p in self.players ]
        )

    def set_player(self, name):
        try:
            last_name, first_name = name.split(' ')
            player = self.team.players.get(first_name=first_name, last_name=last_name)
        except (ValueError, Player.DoesNotExist):
            player = None

        if not player:
            print('Unknown player: %s' % name)
        else:
            player_to_be_changed_num = self._deduce_player_to_be_changed()
            print('changing %s to %s ' % (self.players[player_to_be_changed_num], player))

            field_name = self.players_fields[player_to_be_changed_num]
            self.team.segment.update(**{field_name: player})

            self.last_changed_player_num = player_to_be_changed_num

    def _deduce_player_to_be_changed(self):
        if self.players[0] is None:
            return 0
        if self.players[1] is None:
            return 1
        if self.last_changed_player_num is None:
            return 0  # cannot make reasonable decision
        else:
            return 1 - self.last_changed_player_num  # return the other player num


class Lineup(object):

    def __init__(self, round, segment, table):
        self.round = round
        self.segment = segment
        self.table = table

    @property
    def info(self):
        return 'Round %s, Segment %s, Table %s: %s vs %s' % \
                (self.round, self.segment, self.table, self.segment_obj.home_team.name, self.segment_obj.away_team.name)

    @cached_property
    def segment_obj(self):
        return Segment.objects.get(round=self.round, segment=self.segment, table=self.table)

    @property
    def teams(self):
        return [
            HomeTeamInSegment(self.segment_obj.home_team, self.segment_obj),
            AwayTeamInSegment(self.segment_obj.away_team, self.segment_obj),
        ]