Python periods.Period类代码示例

def site_index(request, template_name='index.html'):
    # most future office hours to show
    MAX_FUTURE_OFFICE_HOURS = 30
    # furthest into the future to display office hours
    MAX_FUTURE_DAYS = 30
    users_available_now = User.objects.filter(profile__is_available=True)
    events = Event.objects.all()
    now = Period(events=events, start=datetime.now(),
                 end=datetime.now() + timedelta(minutes=1))
    occurences = now.get_occurrences()
    users_holding_office_hours_now = map(lambda x: x.event.creator, occurences)
    users = set(list(users_available_now) + users_holding_office_hours_now)
    future = Period(events=events, start=datetime.now(),
                    end=datetime.now() + timedelta(days=MAX_FUTURE_DAYS))
    upcoming_office_hours = []
    already_saw = {}
    for i in future.get_occurrences():
        if len(upcoming_office_hours) >= MAX_FUTURE_OFFICE_HOURS:
            break
        if already_saw.get(i.event.creator):
            continue
        upcoming_office_hours.append(i)
        already_saw[i.event.creator] = 1
    upcoming_office_hours = upcoming_office_hours[:MAX_FUTURE_OFFICE_HOURS]
    return direct_to_template(request, template_name, locals())

def venue_event_feed(request, pk):
    venue = get_object_or_404(Venue, pk=pk)
    if request.is_ajax() and request.method == 'GET':
        if 'start' in request.GET and 'end' in request.GET:
            fro = timezone.make_aware(
                datetime.fromtimestamp(float(request.GET['start'])), timezone.get_current_timezone())
            to = timezone.make_aware(
                datetime.fromtimestamp(float(request.GET['end'])), timezone.get_current_timezone())
            period = Period(Event.objects.exclude(appointment=None).filter(
                appointment__customer=request.user.userprofile.customer).filter(appointment__venue=venue), fro, to)
            data = [{'id': x.event.appointment_set.first().pk,
                     'title': "{}".format(x.event.appointment_set.first().venue_display_name),
                     'userId': [x.event.appointment_set.first().venue.pk],
                     'start': x.start.isoformat(),
                     'end': x.end.isoformat(),
                     'clientId': x.event.appointment_set.first().clientId,
                     'status': x.event.appointment_set.first().status,
                     'tag': getattr(x.event.appointment_set.first().tag, 'html_name', ""),
                     'body': x.event.description
                     }
                    for x in period.get_occurrences()
                    if x.event.appointment_set.first()]
        return HttpResponse(json.dumps(data), content_type="application/json")
    # if all fails
    raise Http404

def task_hour_to_reminder():
    """
    tries to send a reminder approximately one hour before an appointment
    given a time, say 7AM
    we look for appointments that are happening
    between 46 minutes and 1 hour from the given time
    in our case 7:46AM and 8AM
    if time now i6 7:45 we get fro=8:31 and to = 8:45
    we use 46 minutes to avoid cases where events happening at
    exactly *:15, *:30, *:45, or *:00 dont get multiple reminders

    The idea is to catch any appointments happening soon that have NOT been notified
    """
    t = timezone.localtime(timezone.now())
    fro = t + timedelta(minutes=46)
    to = t + timedelta(hours=1)

    period = Period(Event.objects.exclude(appointment=None).exclude(
        appointment__client=None).exclude(
        appointment__status=Appointment.NOTIFIED).exclude(
        appointment__status=Appointment.CANCELED).exclude(
        appointment__status=Appointment.CONFIRMED), fro, to)
    event_objects = period.get_occurrences()
    event_ids = list(set([x.event.id for x in event_objects]))

    send_period_reminders(event_ids, sendsms=True, turn_off_reminders=True, mailgun_campaign_id="fi0bd")

def json_period(request, calender_id):
    calendar = get_object_or_404(Calendar, pk=calender_id)
    ts_start = float(request.GET.get("start", None))
    ts_end = float(request.GET.get("end", None))
    # if not request.is_ajax(): raise Http404

    # period = Month(GET_EVENTS_FUNC(request,calendar)
    # ,date=datetime.datetime(year=2008,month=11,day=1)
    # ,date=datetime.datetime.now()
    # )

    period = Period(
        GET_EVENTS_FUNC(request, calendar),
        start=datetime.datetime.fromtimestamp(ts_start),
        end=datetime.datetime.fromtimestamp(ts_end),
    )

    context = {"calendar": calendar, "occurences": period.get_occurrence_partials()}  # {occurence,class}
    dates = [
        {
            "title": occ["occurrence"].title,
            "start": occ["occurrence"].start.isoformat(),
            "end": occ["occurrence"].end.isoformat(),
            "allDay": False,
        }
        for occ in period.get_occurrence_partials()
    ]

    return HttpResponse(json.dumps(dates), mimetype="application/json")

def view_profile(request, username, template_name="profiles/view_profile.html"):
    user = get_object_or_404(User, username=username)
    display_full_profile = _can_view_full_profile(request.user)
    events = Event.objects.filter(creator=user)
    start = datetime.now()
    end = start + timedelta(days=30)
    period = Period(events=events, start=start, end=end)
    office_hours = period.get_occurrences()
    return render_to_response(template_name, locals(), context_instance=RequestContext(request))

 def testPeriodFromPool(self):
     """
         Test that period initiated with occurrence_pool returns the same occurrences as "straigh" period
         in a corner case whereby a period's start date is equal to the occurrence's end date
     """
     start = datetime.datetime(2008, 1, 5, 9, 0, tzinfo=pytz.utc)
     end = datetime.datetime(2008, 1, 5, 10, 0, tzinfo=pytz.utc)
     parent_period = Period(Event.objects.all(), start, end)
     period = Period(parent_period.events, start, end, parent_period.get_persisted_occurrences(), parent_period.occurrences)
     self.assertEqual(parent_period.occurrences, period.occurrences)

 def render(self, context):
     try:
         true_cal = self.calendar.resolve(context)
         if type(true_cal) != Calendar:
             true_cal = Calendar.objects.get(slug=true_cal)
         period = Period(events=true_cal.events, start=datetime.datetime.now(), end=(datetime.datetime.now()+datetime.timedelta(days=365)))
         context[self.varname] = period.get_occurrences()[0:self.length]
     except template.VariableDoesNotExist:
         context[self.varname] = ''
     return ''

def json_events(request):
    ret = ''
    if request.user.is_authenticated():
        pcal = get_personal_calendar(request.user)
        start = request.GET['start']
        end = request.GET['end']
        allowed_objects = set([])
        perms = ['viewer', 'manager', 'creator']
        ao = {}
        for p in perms:
            ao[p] = get_user_calendars(request.user, [p])
            allowed_objects = allowed_objects.union(set(ao[p]))
        for obj in allowed_objects:
            evt = EventRelation.objects.get_events_for_object(
                obj.content_object)
            if obj.pk == pcal.pk or obj in ao['manager']:
                manager = True
            else:
                manager = False
            if obj.pk == pcal.pk or obj in ao['creator']:
                creator = True
            else:
                creator = False
            period = Period(events=evt, start=datetime.datetime.fromtimestamp(
                float(start)), end=datetime.datetime.fromtimestamp(float(end)))
            occurrences = []
            for o in period.occurrences:
                if period.classify_occurrence(o):
                    o.calendar_id = obj.pk
                    o.calendar_name = obj.calendar.name
                    if o.event.calendar_id == obj.calendar.pk:
                        o.manager = manager
                        o.creator = creator
                    else:
                        o.manager = False
                        o.creator = False
                    if o.id:
                        o.details = EventDetails.objects.get_eventdetails_for_object(
                            o)
                    else:
                        o.details = EventDetails.objects.get_eventdetails_for_object(
                            o.event)

                    if o.details.privacy == 2 and request.user != obj.owner:  # Private event
                        continue
                    else:
                        occurrences.append(o)
            if len(occurrences):
                ret += '"' + obj.calendar.slug + '": ' + \
                    jsondump_occurences(occurrences, request.user) + ','
    ret = ret[:-1]
    ret = '{' + ret + '}'
    # json_data = simplejson.dumps(ret)
    return HttpResponse(ret)

 def get_queryset(self):
     pacific = pytz.timezone('US/Pacific')
     my_events = Event.objects.all()
     my_today = pacific.localize(
         datetime.datetime.now().replace(hour=0, minute=0) \
     )
     upcoming = Period(
         my_events, my_today, my_today+datetime.timedelta(days=30)
     )
     event_id_list = [occurrence.event_id for occurrence in upcoming.get_occurrences()]
     return EventRelation.objects.filter(event_id__in=event_id_list)

class TestPeriod(TestCase):
    def setUp(self):
        rule = Rule.objects.create(frequency="WEEKLY")
        cal = Calendar.objects.create(name="MyCal")
        data = {
            'title': 'Recent Event',
            'start': datetime.datetime(2008, 1, 5, 8, 0, tzinfo=pytz.utc),
            'end': datetime.datetime(2008, 1, 5, 9, 0, tzinfo=pytz.utc),
            'end_recurring_period': datetime.datetime(2008, 5, 5, 0, 0, tzinfo=pytz.utc),
            'rule': rule,
            'calendar': cal,
        }
        Event.objects.create(**data)
        self.period = Period(
            events=Event.objects.all(),
            start=datetime.datetime(2008, 1, 4, 7, 0, tzinfo=pytz.utc),
            end=datetime.datetime(2008, 1, 21, 7, 0, tzinfo=pytz.utc))

    def test_get_occurrences(self):
        occurrence_list = self.period.occurrences
        self.assertEqual(
            ["%s to %s" % (o.start, o.end) for o in occurrence_list],
            [
                '2008-01-05 08:00:00+00:00 to 2008-01-05 09:00:00+00:00',
                '2008-01-12 08:00:00+00:00 to 2008-01-12 09:00:00+00:00',
                '2008-01-19 08:00:00+00:00 to 2008-01-19 09:00:00+00:00',
            ]
        )

    def test_get_occurrence_partials(self):
        occurrence_dicts = self.period.get_occurrence_partials()
        self.assertEqual(
            [
                (occ_dict["class"], occ_dict["occurrence"].start, occ_dict["occurrence"].end)
                for occ_dict in occurrence_dicts
            ],
            [
                (1,
                 datetime.datetime(2008, 1, 5, 8, 0, tzinfo=pytz.utc),
                 datetime.datetime(2008, 1, 5, 9, 0, tzinfo=pytz.utc)),
                (1,
                 datetime.datetime(2008, 1, 12, 8, 0, tzinfo=pytz.utc),
                 datetime.datetime(2008, 1, 12, 9, 0, tzinfo=pytz.utc)),
                (1,
                 datetime.datetime(2008, 1, 19, 8, 0, tzinfo=pytz.utc),
                 datetime.datetime(2008, 1, 19, 9, 0, tzinfo=pytz.utc))
            ])

    def test_has_occurrence(self):
        self.assertTrue(self.period.has_occurrences())
        slot = self.period.get_time_slot(
            datetime.datetime(2008, 1, 4, 7, 0, tzinfo=pytz.utc),
            datetime.datetime(2008, 1, 4, 7, 12, tzinfo=pytz.utc))
        self.assertFalse(slot.has_occurrences())

class TestPeriod(TestCase):
    def setUp(self):
        rule = Rule(frequency="WEEKLY")
        rule.save()
        cal = Calendar(name="MyCal")
        cal.save()
        data = {
            'title': 'Recent Event',
            'start': datetime.datetime(2008, 1, 5, 8, 0),
            'end': datetime.datetime(2008, 1, 5, 9, 0),
            'end_recurring_period': datetime.datetime(2008, 5, 5, 0, 0),
            'rule': rule,
            'calendar': cal
        }
        recurring_event = Event(**data)
        recurring_event.save()
        self.period = Period(events=Event.objects.all(),
                             start=datetime.datetime(2008, 1, 4, 7, 0),
                             end=datetime.datetime(2008, 1, 21, 7, 0))

    def test_get_occurrences(self):
        occurrence_list = self.period.occurrences
        expected = [
            '2008-01-05 08:00:00 to 2008-01-05 09:00:00',
            '2008-01-12 08:00:00 to 2008-01-12 09:00:00',
            '2008-01-19 08:00:00 to 2008-01-19 09:00:00',
        ]
        self.assertEqual(["%s to %s" % (o.start, o.end) for o in occurrence_list], expected)

    def test_get_occurrence_partials(self):
        occurrence_dicts = self.period.get_occurrence_partials()
        self.assertEqual(
            [(occ_dict["class"],
            occ_dict["occurrence"].start,
            occ_dict["occurrence"].end)
            for occ_dict in occurrence_dicts],
            [
                (1,
                 datetime.datetime(2008, 1, 5, 8, 0),
                 datetime.datetime(2008, 1, 5, 9, 0)),
                (1,
                 datetime.datetime(2008, 1, 12, 8, 0),
                 datetime.datetime(2008, 1, 12, 9, 0)),
                (1,
                 datetime.datetime(2008, 1, 19, 8, 0),
                 datetime.datetime(2008, 1, 19, 9, 0))
            ])

    def test_has_occurrence(self):
        self.assert_(self.period.has_occurrences())
        slot = self.period.get_time_slot(datetime.datetime(2008, 1, 4, 7, 0),
                                         datetime.datetime(2008, 1, 4, 7, 12))
        self.failIf(slot.has_occurrences())

    def test_occurrences_sub_period_with_TZ(self):
        start = self.MVD.localize(datetime.datetime(2017, 1, 13))
        end = self.MVD.localize(datetime.datetime(2017, 1, 23))

        period = Period(Event.objects.all(), start, end, tzinfo=self.MVD)

        sub_start = self.MVD.localize(datetime.datetime(2017, 1, 13))
        sub_end = self.MVD.localize(datetime.datetime(2017, 1, 15))
        sub_period = period.get_time_slot(sub_start, sub_end)
        self.assertEqual(
            ["%s to %s" % (o.start, o.end) for o in sub_period.occurrences],
            ['2017-01-14 22:00:00-03:00 to 2017-01-14 23:00:00-03:00'])

class TestPeriod(TestCase):
    def setUp(self):
        rule = Rule(frequency="WEEKLY")
        rule.save()
        cal = Room(name="MyCal")
        cal.save()
        data = {
            "title": "Recent Reservation",
            "start": datetime.datetime(2008, 1, 5, 8, 0),
            "end": datetime.datetime(2008, 1, 5, 9, 0),
            "end_recurring_period": datetime.datetime(2008, 5, 5, 0, 0),
            "rule": rule,
            "room": cal,
        }
        recurring_reservation = Reservation(**data)
        recurring_reservation.save()
        self.period = Period(
            reservations=Reservation.objects.all(),
            start=datetime.datetime(2008, 1, 4, 7, 0),
            end=datetime.datetime(2008, 1, 21, 7, 0),
        )

    def test_get_occurrences(self):
        occurrence_list = self.period.occurrences
        self.assertEqual(
            ["%s to %s" % (o.start, o.end) for o in occurrence_list],
            [
                "2008-01-05 08:00:00 to 2008-01-05 09:00:00",
                "2008-01-12 08:00:00 to 2008-01-12 09:00:00",
                "2008-01-19 08:00:00 to 2008-01-19 09:00:00",
            ],
        )

    def test_get_occurrence_partials(self):
        occurrence_dicts = self.period.get_occurrence_partials()
        self.assertEqual(
            [
                (occ_dict["class"], occ_dict["occurrence"].start, occ_dict["occurrence"].end)
                for occ_dict in occurrence_dicts
            ],
            [
                (1, datetime.datetime(2008, 1, 5, 8, 0), datetime.datetime(2008, 1, 5, 9, 0)),
                (1, datetime.datetime(2008, 1, 12, 8, 0), datetime.datetime(2008, 1, 12, 9, 0)),
                (1, datetime.datetime(2008, 1, 19, 8, 0), datetime.datetime(2008, 1, 19, 9, 0)),
            ],
        )

    def test_has_occurrence(self):
        self.assert_(self.period.has_occurrences())
        slot = self.period.get_time_slot(datetime.datetime(2008, 1, 4, 7, 0), datetime.datetime(2008, 1, 4, 7, 12))
        self.failIf(slot.has_occurrences())

 def test_moved_occurrences(self):
     occurrences = self.recurring_event.get_occurrences(start=self.start,
                                 end=self.end)
     moved_occurrence = occurrences[1]
     span_pre = (moved_occurrence.start, moved_occurrence.end)
     span_post = [x + datetime.timedelta(hours=2) for x in span_pre]
     # check has_occurrence on both periods
     period_pre = Period([self.recurring_event], span_pre[0], span_pre[1])
     period_post = Period([self.recurring_event], span_post[0], span_post[1])
     self.assertTrue(period_pre.has_occurrences())
     self.assertFalse(period_post.has_occurrences())
     # move occurrence
     moved_occurrence.move(moved_occurrence.start+datetime.timedelta(hours=2),
                           moved_occurrence.end+datetime.timedelta(hours=2))
     occurrences = self.recurring_event.get_occurrences(start=self.start,
                                 end=self.end)
     self.assertTrue(occurrences[1].moved)
     # check has_occurrence on both periods (the result should be reversed)
     period_pre = Period([self.recurring_event], span_pre[0], span_pre[1])
     period_post = Period([self.recurring_event], span_post[0], span_post[1])
     self.assertFalse(period_pre.has_occurrences())
     self.assertTrue(period_post.has_occurrences())
     # trigger bug discovered by gautamadude - modifying recurring event
     # breaks link between a persistent occurrence and the occurrence chain
     # leaving an "orphaned" occurrence
     occurrences = self.recurring_event.get_occurrences(start=self.start,
                                 end=self.end)
     self.assertTrue(len(occurrences) == 3)
     self.recurring_event.start = datetime.datetime(2008, 1, 5, 8, 15)
     self.recurring_event.save()
     occurrences_later = self.recurring_event.get_occurrences(start=self.start,
                                 end=self.end)
     self.assertEquals(len(occurrences_later), len(occurrences))

    def setUp(self):
        self.day = Day(
            events=Event.objects.all(),
            date=datetime.datetime(datetime.datetime.now().year, 2, 7, 0, 0, tzinfo=pytz.utc))
        self.day_out_of_limit = Day(
            events=Event.objects.all(),
            date=datetime.datetime(datetime.datetime.now().year + 3, 2, 7, 0, 0, tzinfo=pytz.utc))
        self.day_out_of_limit_lower = Day(
            events=Event.objects.all(),
            date=datetime.datetime(datetime.datetime.now().year - 3, 2, 7, 0, 0, tzinfo=pytz.utc))

        rule = Rule.objects.create(frequency='WEEKLY')
        self.cal = Calendar.objects.create(name='MyCal', slug='MyCalSlug')

        Event.objects.create(
            title='Recent Event',
            start=datetime.datetime(datetime.datetime.now().year, 1, 5, 8, 0, tzinfo=pytz.utc),
            end=datetime.datetime(datetime.datetime.now().year, 1, 5, 9, 0, tzinfo=pytz.utc),
            end_recurring_period=datetime.datetime(datetime.datetime.now().year, 5, 5, 0, 0, tzinfo=pytz.utc),
            rule=rule,
            calendar=self.cal,
        )
        self.period = Period(events=Event.objects.all(),
                             start=datetime.datetime(datetime.datetime.now().year, 1, 4, 7, 0, tzinfo=pytz.utc),
                             end=datetime.datetime(datetime.datetime.now().year, 1, 21, 7, 0, tzinfo=pytz.utc))