Beispiel #1
0
    def _get_all_occurrences(self, room_ids, form, flexible_days=0, reservation_id=None):
        start_dt = form.start_dt.data
        end_dt = form.end_dt.data
        repeat_frequency = form.repeat_frequency.data
        repeat_interval = form.repeat_interval.data
        day_start_dt = datetime.combine(start_dt.date(), time())
        day_end_dt = datetime.combine(end_dt.date(), time(23, 59))
        flexible_start_dt = day_start_dt - timedelta(days=flexible_days)
        flexible_end_dt = day_end_dt + timedelta(days=flexible_days)

        occurrences = ReservationOccurrence.find(
            Reservation.room_id.in_(room_ids),
            Reservation.id != reservation_id,
            ReservationOccurrence.start_dt >= flexible_start_dt,
            ReservationOccurrence.end_dt <= flexible_end_dt,
            ReservationOccurrence.is_valid,
            _join=ReservationOccurrence.reservation,
            _eager=ReservationOccurrence.reservation
        ).options(ReservationOccurrence.NO_RESERVATION_USER_STRATEGY).all()

        candidates = {}
        for days in xrange(-flexible_days, flexible_days + 1):
            offset = timedelta(days=days)
            series_start = start_dt + offset
            series_end = end_dt + offset
            if series_start < flexible_start_dt:
                continue
            candidates[series_start, series_end] = ReservationOccurrence.create_series(series_start, series_end,
                                                                                       (repeat_frequency,
                                                                                        repeat_interval))
        return occurrences, candidates
Beispiel #2
0
    def run(self):
        if not rb_settings.get('notifications_enabled'):
            self._v_logger.info(
                'Digest not sent because notifications are globally disabled')
            return

        digest_start = round_up_month(date.today(), from_day=2)
        digest_end = get_month_end(digest_start)

        occurrences = ReservationOccurrence.find(
            Room.notifications_enabled,
            Reservation.is_accepted,
            Reservation.repeat_frequency == RepeatFrequency.WEEK,
            ReservationOccurrence.is_valid,
            ReservationOccurrence.start_dt >= digest_start,
            ReservationOccurrence.start_dt <= digest_end,
            ~ReservationOccurrence.notification_sent,
            _build_digest_window_filter(),
            _join=[Reservation, Room])

        digests = defaultdict(list)
        for occurrence in occurrences:
            digests[occurrence.reservation].append(occurrence)

        try:
            for reservation, occurrences in digests.iteritems():
                notify_reservation_digest(reservation, occurrences)
                for occurrence in occurrences:
                    occurrence.notification_sent = True
        finally:
            db.session.commit()
Beispiel #3
0
    def run(self):
        if not rb_settings.get('notifications_enabled'):
            self._v_logger.info(
                'Notifications not sent because they are globally disabled')
            return

        occurrences = ReservationOccurrence.find(
            Room.notifications_enabled,
            Reservation.is_accepted,
            Reservation.repeat_frequency != RepeatFrequency.WEEK,
            ReservationOccurrence.is_valid,
            ReservationOccurrence.start_dt >= datetime.now(),
            ~ReservationOccurrence.notification_sent,
            _build_notification_window_filter(),
            _join=[Reservation, Room])

        try:
            for occ in occurrences:
                notify_upcoming_occurrence(occ)
                occ.notification_sent = True
                if occ.reservation.repeat_frequency == RepeatFrequency.DAY:
                    occ.reservation.occurrences.update(
                        {'notification_sent': True})
        finally:
            db.session.commit()
Beispiel #4
0
def roombooking_occurrences_digest():
    if not Config.getInstance().getIsRoomBookingActive():
        logger.info('Digest not sent because room booking is disabled')
        return
    if not rb_settings.get('notifications_enabled'):
        logger.info('Digest not sent because notifications are globally disabled')
        return

    digest_start = round_up_month(date.today(), from_day=2)
    digest_end = get_month_end(digest_start)

    occurrences = ReservationOccurrence.find(
        Room.notifications_enabled,
        Reservation.is_accepted,
        Reservation.repeat_frequency == RepeatFrequency.WEEK,
        ReservationOccurrence.is_valid,
        ReservationOccurrence.start_dt >= digest_start,
        ReservationOccurrence.start_dt <= digest_end,
        ~ReservationOccurrence.notification_sent,
        _build_digest_window_filter(),
        _join=[Reservation, Room]
    )

    digests = defaultdict(list)
    for occurrence in occurrences:
        digests[occurrence.reservation].append(occurrence)

    try:
        for reservation, occurrences in digests.iteritems():
            notify_reservation_digest(reservation, occurrences)
            for occurrence in occurrences:
                occurrence.notification_sent = True
    finally:
        db.session.commit()
Beispiel #5
0
def roombooking_occurrences():
    if not Config.getInstance().getIsRoomBookingActive():
        logger.info('Notifications not sent because room booking is disabled')
        return
    if not rb_settings.get('notifications_enabled'):
        logger.info('Notifications not sent because they are globally disabled')
        return

    occurrences = ReservationOccurrence.find(
        Room.notifications_enabled,
        Reservation.is_accepted,
        Reservation.repeat_frequency != RepeatFrequency.WEEK,
        ReservationOccurrence.is_valid,
        ReservationOccurrence.start_dt >= datetime.now(),
        ~ReservationOccurrence.notification_sent,
        _build_notification_window_filter(),
        _join=[Reservation, Room]
    )

    try:
        for occ in occurrences:
            notify_upcoming_occurrence(occ)
            occ.notification_sent = True
            if occ.reservation.repeat_frequency == RepeatFrequency.DAY:
                occ.reservation.occurrences.update({'notification_sent': True})
    finally:
        db.session.commit()
Beispiel #6
0
    def _process(self):
        if self._overload:
            rooms = []
            occurrences = []
        else:
            rooms = Room.find_all(is_active=True)
            occurrences = (
                ReservationOccurrence.find(
                    Reservation.room_id.in_(room.id for room in rooms),
                    ReservationOccurrence.start_dt >= self.start_dt,
                    ReservationOccurrence.end_dt <= self.end_dt,
                    ReservationOccurrence.is_valid,
                    _join=ReservationOccurrence.reservation,
                    _eager=ReservationOccurrence.reservation,
                )
                .options(ReservationOccurrence.NO_RESERVATION_USER_STRATEGY)
                .all()
            )

        return WPRoomBookingCalendar(
            self,
            rooms=rooms,
            occurrences=occurrences,
            start_dt=self.start_dt,
            end_dt=self.end_dt,
            overload=self._overload,
            max_days=self.MAX_DAYS,
        ).display()
Beispiel #7
0
    def _get_all_occurrences(self, room_ids, form, flexible_days=0, reservation_id=None):
        start_dt = form.start_dt.data
        end_dt = form.end_dt.data
        repeat_frequency = form.repeat_frequency.data
        repeat_interval = form.repeat_interval.data
        day_start_dt = datetime.combine(start_dt.date(), time())
        day_end_dt = datetime.combine(end_dt.date(), time(23, 59))
        flexible_start_dt = day_start_dt - timedelta(days=flexible_days)
        flexible_end_dt = day_end_dt + timedelta(days=flexible_days)

        occurrences = ReservationOccurrence.find(
            Reservation.room_id.in_(room_ids),
            Reservation.id != reservation_id,
            ReservationOccurrence.start_dt >= flexible_start_dt,
            ReservationOccurrence.end_dt <= flexible_end_dt,
            ReservationOccurrence.is_valid,
            _join=ReservationOccurrence.reservation,
            _eager=ReservationOccurrence.reservation
        ).options(ReservationOccurrence.NO_RESERVATION_USER_STRATEGY).all()

        candidates = {}
        for days in xrange(-flexible_days, flexible_days + 1):
            offset = timedelta(days=days)
            series_start = start_dt + offset
            series_end = end_dt + offset
            if series_start < flexible_start_dt:
                continue
            candidates[series_start, series_end] = ReservationOccurrence.create_series(series_start, series_end,
                                                                                       (repeat_frequency,
                                                                                        repeat_interval))
        return occurrences, candidates
Beispiel #8
0
    def _process(self):
        occurrences = ReservationOccurrence.find(
            Reservation.room_id == self._room.id,
            ReservationOccurrence.start_dt >= self._calendar_start,
            ReservationOccurrence.end_dt <= self._calendar_end,
            ReservationOccurrence.is_valid,
            _join=ReservationOccurrence.reservation,
            _eager=ReservationOccurrence.reservation
        ).options(ReservationOccurrence.NO_RESERVATION_USER_STRATEGY).all()

        return self._get_view(room=self._room, start_dt=self._calendar_start, end_dt=self._calendar_end,
                              occurrences=occurrences).display()
Beispiel #9
0
    def _process(self):
        occurrences = ReservationOccurrence.find(
            Reservation.room_id == self._room.id,
            ReservationOccurrence.start_dt >= self._calendar_start,
            ReservationOccurrence.end_dt <= self._calendar_end,
            ReservationOccurrence.is_valid,
            _join=ReservationOccurrence.reservation,
            _eager=ReservationOccurrence.reservation
        ).options(ReservationOccurrence.NO_RESERVATION_USER_STRATEGY).all()

        return self._get_view(room=self._room, start_dt=self._calendar_start, end_dt=self._calendar_end,
                              occurrences=occurrences).display()
Beispiel #10
0
    def run(self):
        occurrences = ReservationOccurrence.find(
            Reservation.is_accepted,
            ~ReservationOccurrence.notification_sent,
            ReservationOccurrence.is_valid,
            ReservationOccurrence.start_dt >= func.now(),
            _build_notification_before_days_filter(settings.get('notification_before_days', 0)),
            _join=[Reservation, Room]
        )

        for occ in occurrences:
            occ.notification_sent = True
            if occ.reservation.repeat_frequency == RepeatFrequency.DAY:
                occ.reservation.occurrences.update({'notification_sent': True})
            notify_upcoming_occurrence(occ)
Beispiel #11
0
    def run(self):
        occurrences = ReservationOccurrence.find(
            Reservation.is_accepted,
            ~ReservationOccurrence.notification_sent,
            ReservationOccurrence.is_valid,
            ReservationOccurrence.start_dt >= func.now(),
            _build_notification_before_days_filter(
                settings.get('notification_before_days', 0)),
            _join=[Reservation, Room])

        try:
            for occ in occurrences:
                notify_upcoming_occurrence(occ)
                occ.notification_sent = True
                if occ.reservation.repeat_frequency == RepeatFrequency.DAY:
                    occ.reservation.occurrences.update(
                        {'notification_sent': True})
        finally:
            db.session.commit()
Beispiel #12
0
    def _process(self):
        if self._overload:
            rooms = []
            occurrences = []
        else:
            rooms = Room.find_all(is_active=True)
            occurrences = (ReservationOccurrence.find(
                Reservation.room_id.in_(room.id for room in rooms),
                ReservationOccurrence.start_dt >= self.start_dt,
                ReservationOccurrence.end_dt <= self.end_dt,
                ReservationOccurrence.is_valid,
                _join=ReservationOccurrence.reservation,
                _eager=ReservationOccurrence.reservation).options(
                    ReservationOccurrence.NO_RESERVATION_USER_STRATEGY).all())

        return WPRoomBookingCalendar(self,
                                     rooms=rooms,
                                     occurrences=occurrences,
                                     start_dt=self.start_dt,
                                     end_dt=self.end_dt,
                                     overload=self._overload,
                                     max_days=self.MAX_DAYS).display()