Exemplo n.º 1
0
    def _add_event(self, event, row):

        self._event_sheet.write(row, 0, date_string(event.date))
        self._event_sheet.write(row, 1, time_string(event.time))
        self._event_sheet.write(row, 2, event.title)
        self._event_sheet.write(row, 3, event.notes)
        self._event_sheet.write(row, 4, event.description)

        for r in GlobalRoleList.roles:
            self._vacancies_sheets[r.description].write(row, 0, event.title + '(' + date_string(event.date) + ')')

        event_jobs = map(_job, event.appointments)
        for d in self._jobs:
            for i, j in enumerate(self._jobs[d]):
                try:
                    index = event_jobs.index(j)
                    appointment = event.appointments[index]
                    if appointment.disabled:
                        self._vacancies_sheets[j[0]].write(row, i + 1, "Disabled", styleDisabled)
                    elif appointment.is_filled():
                        self._vacancies_sheets[j[0]].write(row, i + 1, appointment.person.name)
                    else:
                        self._vacancies_sheets[j[0]].write(row, i + 1, "")

                    event_jobs[index] = None

                except ValueError:
                    self._vacancies_sheets[j[0]].write(row, i + 1, "", styleInvalid)
    def _refresh_events_children(self):

        self._events_Item.takeChildren()
        date = None
        date_item = None
        for event in sorted(self._events, key=lambda w: w.datetime):

            if not event.date == date:
                date = event.date
                date_item = self._add_child(self._events_Item, 0, date_string(date))
                date_item.appointment = None

            event_item = self._add_child(date_item, 0, event.name)

            event_item.appointment = None

            appointment_list = event.appointments
            if self.vacanciesOnly:
                appointment_list = filter(is_vacant, appointment_list)

            for appointment in appointment_list:
                appointment.changed.connect(self._collectingObject.vacancy_changed)
                appointment_item = self._add_child(event_item, 0, str(appointment.role) + '(' + appointment.note + ')')

                appointment_item.appointment = appointment

                this_item = self._add_child(self._rolesItemsDict[appointment.role], 0, event.title + '(' + date_string(
                    event.date) + ')' + '(' + appointment.note + ')')
                this_item.appointment = appointment
Exemplo n.º 3
0
def MultitaskingPersonCheck(events, appointmentsWarningLimit):
    l = []
    for e in events:
        c = Counter(map(person, e.appointments))
        for p in c:
            if p and c[p] > appointmentsWarningLimit:
                error = CheckWarning('The person, ' + p.name + ' is scheduled for ' + str(
                        c[p]) + ' appointments during the same event (' + e.name + date_string(e.date) + time_string(
                    e.time) + ')')
                l.append(error)
            elif p and c[p] > 1:
                error = CheckInformation('The person, ' + p.name + ' is scheduled for ' + str(
                        c[p]) + ' appointments during the same event (' + e.name + date_string(e.date) + time_string(
                    e.time) + ')')
                l.append(error)
    return l
Exemplo n.º 4
0
def event_title(event):
    title = ""
    title += date_string(event.date)
    title += "   "
    title += time_string(event.time)
    title += "   "
    title += event.title
    return title
Exemplo n.º 5
0
 def _html_header(self):
     title = 'Event '
     title += date_string(self._event.date)
     title += '   '
     title += time_string(self._event.time)
     title += '   '
     title += self._event.title
     return HTMLObjects.HTMLHeading(title)
Exemplo n.º 6
0
 def _html_table_row_for_appointment(self, appointment):
     html = HTMLObjects.HTMLTableRow()
     html.add(HTMLObjects.HTMLTableCell(date_string(appointment.date)))
     time = time_string(appointment.time)
     event = str(appointment.event.title)
     html.add(HTMLObjects.HTMLTableCell(time))
     html.add(HTMLObjects.HTMLTableCell(self._role_description(appointment)))
     html.add(HTMLObjects.HTMLTableCell(event))
     return html
Exemplo n.º 7
0
 def _html_table_row_for_appointment(self, appointment):
     html = HTMLObjects.HTMLTableRow()
     html.add(HTMLObjects.HTMLTableCell(date_string(appointment.date)))
     time = time_string(appointment.time)
     event_link = HTMLObjects.HTMLLink(appointment.event.title, "../events/" + event_title(appointment.event) + ".html")
     html.add(HTMLObjects.HTMLTableCell(time))
     html.add(HTMLObjects.HTMLTableCell(self._role_description(appointment)))
     html.add(HTMLObjects.HTMLTableCell(event_link))
     return html
Exemplo n.º 8
0
    def headerData(self, section, orientation, role):

        if role == QtCore.Qt.DisplayRole:
            if orientation == QtCore.Qt.Horizontal:
                if len(self.people()) > 0:
                    return self.people()[section].name
            elif orientation == QtCore.Qt.Vertical:
                if len(self.dates()) > 0:
                    return date_string(self.dates()[section])
Exemplo n.º 9
0
    def _get_events_order(self):

        if self._event_sheet.nrows - 2 != len(self._duration.events):
            raise ExcellImportExportError('There are the wrong number of event entries on the events sheet')

        table_events = []
        for i in range(2, self._event_sheet.nrows):
            if self._event_sheet.cell_type(i, 0) is 0:
                break
            else:
                e = {}
                e['date'] = self._event_sheet.cell_value(i, 0)
                e['time'] = self._event_sheet.cell_value(i, 1)
                e['title'] = self._event_sheet.cell_value(i, 2)
                e['notes'] = self._event_sheet.cell_value(i, 3)
                e['description'] = self._event_sheet.cell_value(i, 4)
                table_events.append(e)

        ordered_events = [None for _ in range(len(self._duration.events))]

        for event in self._duration.events:
            for i, e in enumerate(table_events):
                if e is not None:
                    if e['title'] == event.title and e['notes'] == event.notes and e[
                        'description'] == event.description:
                        if e['date'] == date_string(event.date) and e['time'] == time_string(event.time):
                            ordered_events[i] = event
                            table_events[i] = None

        if None in ordered_events:
            raise ExcellImportExportError('Not all the events of the duration were incoprorated in the sheet')
        for e in table_events:
            if e is not None:
                raise ExcellImportExportError('Not all the events of the sheet were present in the duration')

        for s in self._vacancies_sheets:
            for i, e in enumerate(ordered_events):
                if self._vacancies_sheets[s].cell_value(i + 2, 0) != e.title + '(' + date_string(e.date) + ')':
                    raise ExcellImportExportError('The sheet about ' + s + ' did not have the matching events')

        return ordered_events
Exemplo n.º 10
0
 def _html_table(self):
     table = HTMLObjects.HTMLTable()
     row = HTMLObjects.HTMLTableRow(HTMLObjects.HTMLTableHeaderCell())
     for t in self._times():
         row.add(HTMLObjects.HTMLTableHeaderCell(time_string(t)))
     table.add(row)
     for d in self._dates():
         row = HTMLObjects.HTMLTableRow(HTMLObjects.HTMLTableHeaderCell(date_string(d)))
         for t in self._times():
             correct_appointments = filter(lambda x: x.date == d and x.time == t, self._all_appointments)
             names = map(person_name, correct_appointments)
             if len(names) > 0:
                 string = '<br>'.join(names)
             else:
                 string = ''
             row.add(HTMLObjects.HTMLTableCell(string))
         table.add(row)
     return table
Exemplo n.º 11
0
    def _add_individual(self, person, row):

        self._population_sheet.write(row, 0, person.name)
        self._population_sheet.write(row, 1, person.phone_number)
        self._population_sheet.write(row, 2, person.email)
        self._population_sheet.write(row, 3, person.address)

        self._qualifications_sheet.write(row, 0, person.name)
        self._dates_sheet.write(row, 0, person.name)

        j = 1
        for r in GlobalRoleList.roles:
            if person.suitable_for_role(r):
                self._qualifications_sheet.write(row, j, "Y")
            j += 1

        j = 1
        for d in person.blacklisted_dates():
            self._dates_sheet.write(row, j, date_string(d))
            j += 1
Exemplo n.º 12
0
 def _html_table(self):
     table = HTMLObjects.HTMLTable()
     row = HTMLObjects.HTMLTableRow()
     row.add(HTMLObjects.HTMLTableHeaderCell("Date"))
     row.add(HTMLObjects.HTMLTableHeaderCell("Time"))
     row.add(HTMLObjects.HTMLTableHeaderCell("Event"))
     row.add(HTMLObjects.HTMLTableHeaderCell("People"))
     table.add(row)
     for e in sorted(self._events, key=lambda e: e.datetime()):
         correct_appointments = [a for a in self._all_appointments if e is a.event]
         if len(correct_appointments) > 0:
             link = HTMLObjects.HTMLLink(e.title, "../events/" + event_title(e) + ".html")
             row = HTMLObjects.HTMLTableRow(HTMLObjects.HTMLTableHeaderCell(date_string(e.date)))
             row.add(HTMLObjects.HTMLTableHeaderCell(time_string(e.time)))
             row.add(HTMLObjects.HTMLTableHeaderCell(link))
             names = map(person_name, correct_appointments)
             if len(names) > 0:
                 string = '<br>'.join(names)
             else:
                 string = ''
             row.add(HTMLObjects.HTMLTableCell(string))
             table.add(row)
     return table
Exemplo n.º 13
0
    def _refresh_events_children(self):

        li = []
        self._collect_checked_items(self._events_Item, li)
        enabled = map(lambda i: i.reportable[0], li)
        self._events_Item.takeChildren()
        date = None
        date_item = None
        for event in sorted(self._events, key=lambda w: w.datetime):

            if not event.date == date:
                date = event.date
                date_item = self._add_child(self._events_Item, 0, date_string(date))
                date_item.reportTupple = None

            item = self._add_child(date_item, 0, event.name)

            if event in enabled:
                checked = QtCore.Qt.Checked
            else:
                checked = QtCore.Qt.Unchecked

            item.setCheckState(0, checked)
            item.reportTupple = event, self._eventReporter
Exemplo n.º 14
0
def IncompatibleMultitaskingPersonCheck(events):
    l = []
    for e in events:
        a = list(e.appointments)
        b = list(e.appointments)
        for appointment in a:
            b.remove(appointment)
            for otherAppointment in b:
                if appointment.is_filled() and appointment.person == otherAppointment.person and not appointment.role.compatible_with(
                        otherAppointment.role):
                    error = CheckError(
                        'The person, ' + appointment.person.name + ' is scheduled for conflicting appointments during the same event (' + e.name + date_string(
                            e.date) + time_string(e.time) + ')')
                    l.append(error)

    return l
Exemplo n.º 15
0
    def _update(self):
        if self._appointment is None:
            self.descriptionBox.setText('No Appointment Selected')
            self.notesBox.setText('')
            self.checkBox.setChecked(True)
        else:
            self.descriptionBox.setText(
                str(self._appointment.role) + '(' + self._appointment.event.title + ')' + '(' + date_string(
                    self._appointment.date) + ')')
            self.notesBox.setText(self._appointment.note)
            self.checkBox.setChecked(self._appointment.disabled)

        if self._appointment is None:
            self.personLine.setText('')
            self.vacateButton.setEnabled(False)
        elif self._appointment.disabled:
            self.personLine.setText('***Disabled***')
            self.vacateButton.setEnabled(False)
        elif self._appointment.is_filled():
            self.personLine.setText(str(self._appointment.person))
            self.vacateButton.setEnabled(True)
        else:
            self.personLine.setText('***Vacant***')
            self.vacateButton.setEnabled(False)
Exemplo n.º 16
0
def BlacklistedDatePersonCheck(appointments):
    l = []
    for a in appointments:
        if a.is_filled():
            if not a.person.is_available_on_date(a.date):
                error = CheckError(
                    'The person, ' + a.person.name + ' is scheduled for ' + a.role.description + ' on ' + date_string(
                        a.date) + ' but is not available on that date')
                l.append(error)
    return l
Exemplo n.º 17
0
def UnqualifiedPersonCheck(appointments):
    l = []
    for a in appointments:
        if a.is_filled():
            if not a.person.suitable_for_role(a.role):
                error = CheckError(
                    'The person, ' + a.person.name + ' is scheduled for ' + a.role.description + ' on ' + date_string(
                        a.date) + ' but is not qualified as a ' + a.role.description)
                l.append(error)
    return l
Exemplo n.º 18
0
def UnfilledAppointmentCheck(events):
    l = []
    for e in events:
        a = list(e.appointments)
        for appointment in a:
            if not appointment.is_filled() and not appointment.disabled:
                error = CheckError(
                    'The appointment, ' + appointment.role.description + ' is unfilled during the event (' + e.name + date_string(
                        e.date) + time_string(e.time) + ')')
                l.append(error)

    return l
Exemplo n.º 19
0
def MultipleProximalAppointmentsPersonCheck(appointments, population, permittedTimedelta):
    l = []
    for p in population:
        pAppointments = filter(lambda a: a.person == person, appointments)
        remainingPAppointments = set(pAppointments)
        for appointment in pAppointments:
            remainingPAppointments.remove(appointment)
            proximalAppointments = filter(lambda a: abs(a.datetime - appointment.datetime) <= permittedTimedelta,
                                          remainingPAppointments)
            for app in proximalAppointments:
                warning = CheckWarning(
                    'The person, ' + p.name + ' has 2 oppointments within a short timescale (one of them is' + appointment.role + date_string(
                        appointment.date) + time_string(appointment.time) + ') the other is (' + app.role + date_string(
                        app.date) + time_string(app.time) + +') within ' + str(permittedTimedelta))
                l.append(warning)

    return l