RoomScheduler/models.py at master · troyyyang/RoomScheduler · GitHub

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
class Meeting:
    def __init__(self, start_time, end_time, num_people, name):
        self.__start_time = start_time
        self.__end_time = end_time
        self.__num_people = num_people
        self.__name = name

    def set_start_time(self, start_time):
        self.__start_time = start_time

    def set_end_time(self, end_time):
        self.__end_time = __end_time

    def set_num_people(self, num_people):
        self.__num_people = num_people

    def set_name(self, name):
        self.__name = name

    def get_start_time(self):
        return self.__start_time

    def get_end_time(self):
        return self.__end_time

    def get_num_people(self):
        return self.__num_people

    def get_name(self):
        return self.__name

    def __eq__(self, other):
        return (self.__name, self.__start_time, self.__end_time,
                other.__num_people) == (other.get_name(),
                                        other.get_start_time(),
                                        other.get_end_time(),
                                        other.get_num_people())

    def __ne__(self, other):
        return not (self == other)

    def __hash__(self):
        return hash((self.__name, self.__num_people, self.__start_time,
                     self.__end_time))

    def __lt__(self, other):
        return (self.__num_people * (
            (self.get_end_time() - self.get_start_time()).total_seconds()
        )) < (other.get_num_people() * (
            (other.get_end_time() - other.get_start_time()).total_seconds()))

    def __le__(self, other):
        return (self.get_num_people() * (
            (self.get_end_time() - self.get_start_time()).total_seconds()
        )) <= (other.__num_people * (
            (other.get_end_time() - other.get_start_time()).total_seconds()))

    def __gt__(self, other):
        return (self.get_num_people() * (
            (self.get_end_time() - self.get_start_time()).total_seconds()
        )) > (other.__num_people * (
            (other.get_end_time() - other.get_start_time()).total_seconds()))

    def __ge__(self, other):
        return (self.get_num_people() * (
            (self.get_end_time() - self.get_start_time()).total_seconds()
        )) >= (other.__num_people * (
            (other.get_end_time() - other.get_start_time()).total_seconds()))


class Room:
    def __init__(self, name, num_chairs):
        self.__name = name
        self.__num_chairs = num_chairs

    def set_name(self, name):
        self.__name = name

    def set_num_chairs(self, num_chairs):
        self.__num_chairs = num_chairs

    def get_name(self):
        return self.__name

    def get_num_chairs(self):
        return self.__num_chairs

    def __eq__(self, other):
        return (self.__name, self.__num_chairs) == (other.get_name(),
                                                    other.get_num_chairs())

    def __ne__(self, other):
        return not (self == other)

    def __hash__(self):
        return hash((self.__name, self.__num_chairs))

    def __lt__(self, other):
        return self.get_num_chairs() < other.get_num_chairs()

    def __le__(self, other):
        return self.get_num_chairs() <= other.get_num_chairs()

    def __gt__(self, other):
        return self.get_num_chairs() > other.get_num_chairs()

    def __ge__(self, other):
        return self.get_num_chairs() >= other.get_num_chairs()


class Calendar:
    def __init__(self):
        self.__meetings = {}

    def get_meetings(self):
        return self.__meetings

    def add_room(self, room):
        if (room not in self.__meetings):
            self.__meetings[room] = set()
            return True
        return False

    def add_meeting(self, meeting, room):
        if (self._check_time_conflicts(meeting, room)):
            self.__meetings[room].add(meeting)
            return True
        else:
            return False

    def _check_time_conflicts(self, meeting, room):
        for mtg in self.__meetings[room]:
            if (meeting.get_start_time() < mtg.get_start_time()):
                if (meeting.get_end_time() > mtg.get_start_time()):
                    return False
            elif (meeting.get_start_time() > mtg.get_start_time()):
                if (mtg.get_end_time() > meeting.get_start_time()):
                    return False
            else:
                return False
        return True