Python utils.get_date函数代码示例

    def clean(self):
        """Clean Form."""
        cdata = super(UserStatusForm, self).clean()

        if self.instance.id:
            return cdata

        tomorrow = get_date(days=1)
        max_period = get_date(weeks=MAX_UNAVAILABILITY_PERIOD)
        if 'expected_date' in cdata:
            if cdata['expected_date'] < tomorrow:
                msg = ('Return day cannot be earlier than {0}'
                       .format(tomorrow.strftime('%d %B %Y')))
                self._errors['expected_date'] = self.error_class([msg])
            if cdata['expected_date'] > max_period:
                msg = (u'The maximum period for unavailability is until {0}.'
                       .format(max_period.strftime('%d %B %Y')))
                sop = mark_safe(msg + (' For more information please check '
                                       'the %s Leaving SOP') % LEAVING_SOP_URL)
                self._errors['expected_date'] = self.error_class([sop])

        if ('is_replaced' in cdata and
                cdata['is_replaced'] and not cdata['replacement_rep']):
            msg = 'Please select a replacement Rep during your absence.'
            self._errors['replacement_rep'] = self.error_class([msg])

        return cdata

def notify_event_owners_to_input_metrics():
    """Send an email to event creators.

    After an event has finished event creators are notified
    that they should input the actual metrics for the event.
    """
    start = datetime.combine(get_date(days=-1), datetime.min.time())
    end = datetime.combine(get_date(days=-1), datetime.max.time())
    events = Event.objects.filter(
        end__range=[start, end], has_new_metrics=True, eventmetricoutcome__outcome__isnull=True
    )
    events = events.distinct()

    event_model = ContentType.objects.get_for_model(Event)
    for event in events:
        # Before sending an email check that an action item already exists.
        # If it does, then we have already sent this email.

        action_item = ActionItem.objects.filter(content_type=event_model, object_id=event.id)
        if not action_item.exists():
            subject = "[Reminder] Please add the actual metrics for event {0}".format(event.name)
            template = "email/event_creator_notification_to_input_metrics.txt"
            data = {"event": event}
            send_remo_mail(subject=subject, email_template=template, recipients_list=[event.owner.id], data=data)
            ActionItem.create(instance=event)

    def clean(self):
        """Clean Form."""
        cdata = super(UserStatusForm, self).clean()

        if self.instance.id:
            cdata["start_date"] = self.instance.start_date
            return cdata

        tomorrow = get_date(days=1)
        today = get_date()
        max_period = get_date(weeks=MAX_UNAVAILABILITY_PERIOD)

        if "start_date" in cdata:
            if cdata["start_date"] < today:
                msg = u"Start date cannot be in the past."
                self._errors["start_date"] = self.error_class([msg])

        if "expected_date" in cdata:
            if cdata["expected_date"] < tomorrow:
                msg = u"Return day cannot be earlier than {0}".format(tomorrow.strftime("%d %B %Y"))
                self._errors["expected_date"] = self.error_class([msg])
            if cdata["expected_date"] < cdata["start_date"]:
                msg = u"Return date cannot be before start date."
                self._errors["expected_date"] = self.error_class([msg])
            if cdata["expected_date"] > max_period:
                msg = u"The maximum period for unavailability is until {0}.".format(max_period.strftime("%d %B %Y"))
                sop = mark_safe(msg + (" For more information please check " "the %s Leaving SOP") % LEAVING_SOP_URL)
                self._errors["expected_date"] = self.error_class([sop])

        if "is_replaced" in cdata and cdata["is_replaced"] and not cdata["replacement_rep"]:
            msg = "Please select a replacement Rep during your absence."
            self._errors["replacement_rep"] = self.error_class([msg])

        return cdata

 def test_base(self):
     user = UserFactory.create()
     date = get_date()
     data = {'expected_date': date}
     form = UserStatusForm(data, instance=UserStatus(user=user))
     ok_(form.is_valid())
     db_obj = form.save()
     eq_(db_obj.expected_date, get_date())
     eq_(db_obj.user.get_full_name(), user.get_full_name())

def set_unavailability_flag():
    """Set the unavailable flag in UserStatus.

    This task runs every 12 hours and sets the unavailable flag to True
    in the case that a user has submitted a 'break notification' with a start
    date in the future."""

    (UserStatus.objects.filter(start_date__range=[get_date(-1), get_date()],
                               is_unavailable=False)
                       .update(is_unavailable=True))

 def test_base(self):
     mentor = UserFactory.create()
     user = UserFactory.create(userprofile__mentor=mentor)
     date = get_date(days=1)
     data = {"expected_date": date}
     form = UserStatusForm(data, instance=UserStatus(user=user))
     ok_(form.is_valid())
     db_obj = form.save()
     eq_(db_obj.expected_date, get_date(days=1))
     eq_(db_obj.user.get_full_name(), user.get_full_name())

def resolve_action_items():
    # avoid circular dependencies
    from remo.voting.models import Poll

    start = datetime.combine(get_date(days=-1), datetime.min.time())
    end = datetime.combine(get_date(days=-1), datetime.max.time())
    polls = Poll.objects.filter(end__range=[start, end])
    action_model = ContentType.objects.get_for_model(Poll)
    items = ActionItem.objects.filter(content_type=action_model, object_id__in=polls)
    items.update(resolved=True)

 def test_expected_date_before_start_date(self):
     mentor = UserFactory.create()
     user = UserFactory.create(userprofile__mentor=mentor)
     start_date = get_date(4)
     expected_date = get_date(days=2)
     data = {'start_date': start_date,
             'expected_date': expected_date}
     form = UserStatusForm(data, instance=UserStatus(user=user))
     ok_(not form.is_valid())
     ok_('expected_date' in form.errors)

def zero_current_streak():
    """Zero current streak.

    Zero current streak for users without a report in the last week.
    """

    reps = User.objects.filter(~Q(ng_reports__report_date__range=[get_date(-7), get_date()]), groups__name="Rep")

    for rep in reps:
        rep.userprofile.current_streak_start = None
        rep.userprofile.save()

 def remove_unavailability_status(self):
     user = UserFactory.create()
     date = get_date()
     data = {'expected_date': date}
     user_status = UserStatusFactory.create(user=user, expected_date=date)
     form = UserStatusForm(data, instance=user_status)
     ok_(form.is_valid())
     ok_(not user_status.end_date)
     db_obj = form.save()
     eq_(db_obj.expected_date, get_date())
     eq_(db_obj.user.get_full_name(), user.get_full_name())
     ok_(db_obj.return_date)

    def save(self, *args, **kwargs):
        """Create post event data report."""
        event = super(PostEventForm, self).save()

        activity = Activity.objects.get(name=ACTIVITY_POST_EVENT_METRICS)
        reports = NGReport.objects.filter(event=event, activity=activity)

        if not reports:
            up = event.owner.userprofile
            attrs = {
                'activity': activity,
                'report_date': get_date(),
                'longitude': up.lon,
                'latitude': up.lat,
                'location': '%s, %s, %s' % (up.city, up.region, up.country),
                'link': get_event_link(event),
                'is_passive': True,
                'event': event,
                'user': event.owner
            }

            report = NGReport.objects.create(**attrs)
            report.functional_areas.add(*event.categories.all())
            statsd.incr('reports.create_passive_post_event_metrics')

        return event

    def test_extend_voting_period_majority(self):
        bug = BugFactory.create()
        start = now().replace(microsecond=0)
        end = datetime.combine(get_date(days=1), datetime.min.time())

        user = UserFactory.create(groups=['Admin'])
        group = Group.objects.get(name='Council')
        User.objects.filter(groups__name='Council').delete()
        UserFactory.create_batch(9, groups=['Council'])

        automated_poll = PollFactoryNoSignals.create(name='poll',
                                                     start=start, end=end,
                                                     valid_groups=group,
                                                     created_by=user,
                                                     automated_poll=True,
                                                     bug=bug)

        radio_poll = RadioPollFactory.create(poll=automated_poll,
                                             question='Budget Approval')
        RadioPollChoiceFactory.create(answer='Approved', votes=5,
                                      radio_poll=radio_poll)
        RadioPollChoiceFactory.create(answer='Denied', votes=3,
                                      radio_poll=radio_poll)

        extend_voting_period()

        poll = Poll.objects.get(pk=automated_poll.id)
        eq_(poll.end.year, end.year)
        eq_(poll.end.month, end.month)
        eq_(poll.end.day, end.day)
        eq_(poll.end.hour, 0)
        eq_(poll.end.minute, 0)
        eq_(poll.end.second, 0)
        ok_(not poll.is_extended)

 def test_base(self):
     mentor = UserFactory.create()
     rep = UserFactory.create(userprofile__mentor=mentor)
     UserStatusFactory.create(user=rep, start_date=get_date(days=-1), is_unavailable=False)
     set_unavailability_flag()
     status = UserStatus.objects.get(user=rep)
     ok_(status.is_unavailable)

    def save(self, *args, **kwargs):
        """Create post event data report."""
        event = super(PostEventForm, self).save()

        activity = Activity.objects.get(name=ACTIVITY_POST_EVENT_METRICS)
        reports = NGReport.objects.filter(event=event, activity=activity)

        if not reports:
            up = event.owner.userprofile
            attrs = {
                "activity": activity,
                "report_date": get_date(),
                "longitude": up.lon,
                "latitude": up.lat,
                "location": "%s, %s, %s" % (up.city, up.region, up.country),
                "link": get_event_link(event),
                "is_passive": True,
                "event": event,
                "user": event.owner,
            }

            report = NGReport.objects.create(**attrs)
            report.functional_areas.add(*event.categories.all())
            statsd.incr("reports.create_passive_post_event_metrics")

        return event

def extend_voting_period():
    """Extend voting period by EXTEND_VOTING_PERIOD if there is no
    majority decision.

    """

    # avoid circular dependencies
    from remo.voting.models import Poll

    tomorrow = get_date(days=1)
    review_count = User.objects.filter(groups__name='Review').count()

    query_start = make_aware(datetime.combine(tomorrow, datetime.min.time()), pytz.UTC)
    query_end = make_aware(datetime.combine(tomorrow, datetime.max.time()), pytz.UTC)
    polls = Poll.objects.filter(end__range=[query_start, query_end])

    for poll in polls:
        if not poll.is_extended:
            budget_poll = poll.radio_polls.get(question='Budget Approval')
            majority = reduce(or_, map(lambda x: x.votes > review_count / 2,
                                       budget_poll.answers.all()))
            if not majority:
                poll.end += timedelta(seconds=EXTEND_VOTING_PERIOD)
                poll.save()
                subject = '[Urgent] Voting extended for {0}'.format(poll.name)
                recipients = (User.objects.filter(groups=poll.valid_groups)
                              .exclude(pk__in=poll.users_voted.all())
                              .values_list('id', flat=True))
                ctx_data = {'poll': poll}
                template = 'emails/voting_vote_reminder.jinja'
                send_remo_mail.delay(subject=subject,
                                     recipients_list=recipients,
                                     email_template=template,
                                     data=ctx_data)