コード例 #1
0
ファイル: utils.py プロジェクト: hoosteeno/remo
def count_user_ng_reports(user, current_streak=False,
                          longest_streak=False, period=0):
    """Return the number of reports of a user over

    a period of time. If current_streak is True return the
    current streak of a user. Arg period expects weeks
    eg 2 means 2 * 7 = 14 days.
    """
    end_period = utc_now()
    start_period = datetime(2011, 01, 01)

    if current_streak:
        start_period = user.userprofile.current_streak_start
        end_period = user.userprofile.current_streak_end
        if (not end_period or
                (utc_now().date() - end_period > timedelta(days=1))):
            return 0
    elif longest_streak:
        start_period = user.userprofile.longest_streak_start
        end_period = user.userprofile.longest_streak_end
    elif period > 0:
            start_period = utc_now().date() - timedelta(days=(period * 7))

    query = user.ng_reports.filter(report_date__range=(start_period,
                                                       end_period))

    return query.count()
コード例 #2
0
ファイル: test_util.py プロジェクト: hoosteeno/remo
 def test_longest_streak(self):
     user = UserFactory.create()
     past_day = utc_now().date() - timedelta(days=30)
     # Add 7 continuous reports somewhere in the past
     for i in range(7, 0, -1):
         NGReportFactory.create(user=user,
                                report_date=(past_day - timedelta(days=i)))
     # Add a report, one each day for the last 4 days (5 reports)
     for i in range(6, 0, -1):
         NGReportFactory.create(user=user,
                                report_date=(utc_now().date() -
                                             timedelta(days=i)))
     eq_(count_user_ng_reports(user, longest_streak=True), 7)
コード例 #3
0
    def test_owner_can_change_min_publish_date(self):
        project = self._get_new_project_with_lessons()

        date_future = utc_now() + timedelta(hours=1)
        self._test_can_change_min_publish_date(project, self.owner_user, Project.PUBLISH_MODE_EDIT, date_future)
        self._test_can_change_min_publish_date(project, self.owner_user, Project.PUBLISH_MODE_REVIEW, date_future)
        self._test_can_change_min_publish_date(project, self.owner_user, Project.PUBLISH_MODE_READY, date_future)

        date_past = utc_now() - timedelta(hours=1)
        self._test_can_change_min_publish_date(project, self.owner_user, Project.PUBLISH_MODE_EDIT, date_past)
        self._test_can_change_min_publish_date(project, self.owner_user, Project.PUBLISH_MODE_REVIEW, date_past)
        self._test_can_change_min_publish_date(project, self.owner_user, Project.PUBLISH_MODE_READY, date_past)

        self._test_can_change_min_publish_date(project, self.owner_user, Project.PUBLISH_MODE_EDIT, None)
        self._test_can_change_min_publish_date(project, self.owner_user, Project.PUBLISH_MODE_REVIEW, None)
        self._test_can_change_min_publish_date(project, self.owner_user, Project.PUBLISH_MODE_READY, None)
コード例 #4
0
ファイル: tasks.py プロジェクト: omni360/inspiration-edu-api
def publish_ready_projects():
    ready_projects_to_publish = api.models.Project.objects.filter(
        publish_mode=api.models.Project.PUBLISH_MODE_READY,
        min_publish_date__lte=utc_now(),
    )
    published_projects_ids = []
    for project in ready_projects_to_publish:
        old_publish_mode = project.publish_mode
        project.publish_mode = api.models.Project.PUBLISH_MODE_PUBLISHED
        project.save()
        published_projects_ids.append(project.id)
        project.notify_owner(
            'project_publish_mode_change_by_target',
            {
                'target': None,
                'description': 'Project "%s" published because publication date has arrived - %s.' %(project.title, project.min_publish_date.strftime('%Y-%m-%d %H:%M')),
                'publishMode': project.publish_mode,
                'oldPublishMode': old_publish_mode,
                'publishDate': project.publish_date.strftime('%Y-%m-%d %H:%M'),
            },
            send_mail_with_template='IGNITE_notification_publish_mode_change',
        )
    if published_projects_ids:
        logger = get_task_logger('publish_ready_projects')
        logger.info('Published %i projects that were ready: %s.', len(published_projects_ids), ', '.join([str(x) for x in published_projects_ids]))
コード例 #5
0
ファイル: tasks.py プロジェクト: omni360/inspiration-edu-api
def notify_user(recipient, actor, verb, **kwargs):
    """
    Handler function to create Notification instance upon action signal call.
    """

    new_notification = Notification(
        recipient = recipient,
        actor_content_type=ContentType.objects.get_for_model(actor),
        actor_object_id=actor.pk,
        verb=text_type(verb),
        public=bool(kwargs.pop('public', False)),
        description=kwargs.pop('description', None),
        timestamp=kwargs.pop('timestamp', utc_now()),
        level=kwargs.pop('level', Notification.LEVELS.info),
    )

    for opt in ('target', 'action_object'):
        obj = kwargs.pop(opt, None)
        if not obj is None:
            setattr(new_notification, '%s_object_id' % opt, obj.pk)
            setattr(new_notification, '%s_content_type' % opt,
                    ContentType.objects.get_for_model(obj))

    if len(kwargs) and EXTRA_DATA:
        new_notification.data = kwargs

    new_notification.save()

    return new_notification
    def test_pending_student_doesnt_get_access_to_project(self):
        """Make sure that if a student is pending to the classroom, she doesn't get access to the locked project"""
        
        timestamp = utc_now()
        
        classroom = Classroom(title='my classroom', owner=self.owner)
        classroom.save()

        pic = ProjectInClassroom(project=self.locked_projects.first(), classroom=classroom, order=0)
        pic.save()
        
        # Add student.
        new_student = get_user_model().objects.filter(
            is_child=False
        ).exclude(
            id__in=Purchase.objects.all().values_list('user_id', flat=True)
        ).first()
        ClassroomState(
            classroom=classroom,
            user=new_student,
            status=ClassroomState.PENDING_STATUS,
        ).save()

        purchases_count = Purchase.objects.all().count()

        add_permissions_to_classroom_students(classroom)

        self.assertEqual(purchases_count, Purchase.objects.all().count())

        # Cleanup
        ClassroomState.objects.filter(classroom=classroom).delete()
        ProjectInClassroom.objects.filter(classroom=classroom).delete()
        classroom.delete()
        Purchase.objects.filter(added__gte=timestamp).delete()
コード例 #7
0
ファイル: views.py プロジェクト: omni360/inspiration-edu-api
    def get(self, request, *args, **kwargs):
        #todo: add permissions
        project = self.get_object()
        cached_project_analytics = cache.get('project_analytics_%s' % project.id)
        if cached_project_analytics and not request.query_params.get('hardRefresh', False):
            return Response(cached_project_analytics)
        else:
            project_lessons_list = list(project.lessons.all())  # materialize list to avoid database access (ordered by order by default)
            data = {
                'usersStartedProject': project.students_count,
                'usersCompletedProject': project.registrations.filter(is_completed=True).count(),
                'lessonsOrder': [x.id for x in project_lessons_list],
                'lessonsTitles': {lesson.id: lesson.title for lesson in project_lessons_list},
                'usersStartedLessons': {lesson.id: lesson.registrations.all().count() for lesson in project_lessons_list},
                'usersCompletedLessons': {lesson.id: lesson.registrations.filter(is_completed=True).count() for lesson in project_lessons_list},
                'usersCompletedSteps': {
                    lesson.id: {
                        step.order: step.stepstate_set.all().count() for step in lesson.steps.all()
                        } for lesson in project_lessons_list
                    },
                'analyticsLastUpdated': utc_now(),
            }
            cache.set('project_analytics_%s' % project.id, data, timeout=24*60*60)

            return Response(data)
コード例 #8
0
ファイル: __init__.py プロジェクト: AndyKovv/hostel
 def get_time_until_run(cls):
     try:
         last_job = CronJobLog.objects.filter(
             code=cls.code).latest('start_time')
     except CronJobLog.DoesNotExist:
         return timedelta()
     return (last_job.start_time +
             timedelta(minutes=cls.schedule.run_every_mins) - utc_now())
コード例 #9
0
ファイル: test_util.py プロジェクト: prameet-jain/remo
 def test_current_streak(self):
     user = UserFactory.create()
     # Add a report every 22 hours for the last 4 days (5 reports)
     for i in range(0, 4):
         NGReportFactory.create(user=user,
                                report_date=(utc_now().date() -
                                             timedelta(days=i)))
     eq_(count_user_ng_reports(user, current_streak=True), 4)
コード例 #10
0
ファイル: helpers.py プロジェクト: prameet-jain/remo
def date_to_weeks(end_date, start_date=None):
    """Given a past date, return the number of
    weeks passed compared to today.
    """
    if not start_date:
        start_date = utc_now().date()
    number_of_weeks = ceil(float((start_date - end_date).days) / float(7))
    return int(number_of_weeks) or 1
コード例 #11
0
ファイル: test_util.py プロジェクト: prameet-jain/remo
 def test_get_last_two_weeks_reports(self):
     user = UserFactory.create()
     # Add 4 reports more than a day apart
     for i in range(8, 0, -2):
         NGReportFactory.create(user=user,
                                report_date=(utc_now().date() -
                                             timedelta(days=i)))
     # Get the reports added in the last two weeks
     eq_(count_user_ng_reports(user, period=2), 4)
コード例 #12
0
ファイル: __init__.py プロジェクト: molog/django-cron
 def get_time_until_run(cls):
     from django_cron.models import CronJobLog
     try:
         last_job = CronJobLog.objects.filter(
             code=cls.code).latest('start_time')
     except CronJobLog.DoesNotExist:
         return timedelta()
     return (last_job.start_time +
             timedelta(minutes=cls.schedule.run_every_mins) - utc_now())
コード例 #13
0
 def test_get_last_ten_weeks_reports(self):
     user = UserFactory.create()
     # Add 4 reports more than a day apart
     for i in range(8, 0, -2):
         NGReportFactory.create(user=user,
                                report_date=(utc_now().date() -
                                             timedelta(days=i)))
     # Get the reports added in the last 10 weeks
     eq_(count_user_ng_reports(user, period=10), 4)
コード例 #14
0
 def delete_stale_invitations(cls, stale_days=None):
     '''
     Deletes stale classroom invitations.
     Default value of life days is read from stale_days (default 14).
     '''
     if stale_days is None:
         stale_days = cls.default_stale_days
     cls.objects.active().filter(
         added__lt=utc_now() - timedelta(days=stale_days)
     ).delete()
    def test_update_permissions_user_already_has_teach_permission(self):
        
        timestamp = utc_now()

        classroom = Classroom(title='my classroom', owner=self.owner)
        classroom.save()

        pic = ProjectInClassroom(project=self.locked_projects.first(), classroom=classroom, order=0)
        pic.save()
        
        # Find an adult student.
        student = get_user_model().objects.filter(
            is_child=False,
        ).exclude(
            id=self.owner.id
        ).first()

        # The student already has a view permission
        purchase = Purchase(user=student, project=self.locked_projects.first(), permission=Purchase.TEACH_PERM)
        purchase.save()

        cs = ClassroomState(
            classroom=classroom,
            user=student,
            status=ClassroomState.APPROVED_STATUS
        )

        purchases_count = Purchase.objects.all().count()

        # Add student to classroom
        cs.save()
        add_permissions_to_classroom_students(classroom)

        # Check that the student still has a view permission.
        self.assertTrue(Purchase.objects.filter(
            user=student,
            project=self.locked_projects.first(),
            permission=Purchase.TEACH_PERM
        ).exists())

        # Student doesn't have an additional purchase with a view permission.
        self.assertFalse(Purchase.objects.filter(
            user=student,
            project=self.locked_projects.first(),
            permission=Purchase.VIEW_PERM
        ).exists())

        # The amount of purchases didn't change.
        self.assertEqual(purchases_count, Purchase.objects.all().count())

        # Cleanup
        cs.delete()
        pic.delete()
        classroom.delete()
        Purchase.objects.filter(added__gte=timestamp).delete()
    def test_update_permissions_same_moderator_for_different_children(self):
        classroom = Classroom(title='my classroom', owner=self.owner)
        classroom.save()

        pic = ProjectInClassroom(project=self.locked_projects.first(), classroom=classroom, order=0)
        pic.save()
        
        # Find a student with 2 moderators who are not the project owner.
        potential_moderators = get_user_model().objects.filter(
            id__in=ChildGuardian.objects.exclude(
                guardian=self.owner
            ).values_list('guardian_id', flat=True)
        ).exclude(id=self.owner.id)
        for m in potential_moderators:
            if m.childguardian_child_set.all().count() > 1:
                new_students = get_user_model().objects.filter(
                    id__in=m.childguardian_child_set.all().values_list('child_id', flat=True)
                )
                moderator = m
                break

        classroom_states = [ClassroomState(
            classroom=classroom,
            user=s,
            status=ClassroomState.APPROVED_STATUS
        ) for s in new_students]

        timestamp = utc_now()

        purchases_count = Purchase.objects.all().count()

        # Add student to classroom
        [cs.save() for cs in classroom_states]
        add_permissions_to_classroom_students(classroom)

        # Check that the moderator for the students got a view permission.
        p = Purchase.objects.filter(
            user=moderator,
            project=self.locked_projects.first(),
            permission=Purchase.VIEW_PERM
        )
        self.assertTrue(p.exists())

        # The expected amount of new purchases is the same as the amount of 
        # new students + their moderators.
        new_purchases = new_students.count() + get_user_model().objects.filter(
            childguardian_child_set__child_id__in=new_students.values_list('id', flat=True)
        ).distinct().count()
        self.assertEqual(purchases_count + new_purchases, Purchase.objects.all().count())

        # Cleanup
        [cs.delete() for cs in classroom_states]
        pic.delete()
        classroom.delete()
        Purchase.objects.filter(added__gte=timestamp).delete()
    def test_update_permissions_propagation_multiple_moderators_for_same_child(self):
        
        classroom = Classroom(title='my classroom', owner=self.owner)
        classroom.save()

        pic = ProjectInClassroom(project=self.locked_projects.first(), classroom=classroom, order=0)
        pic.save()
        
        # Find a student with 2 moderators who are not the project owner.
        potential_students = get_user_model().objects.filter(
            id__in=ChildGuardian.objects.exclude(
                       guardian=self.owner
                    ).values_list('child_id', flat=True)
            )
        for s in potential_students:
            if s.childguardian_guardian_set.exclude(guardian=self.owner).count() > 1:
                new_student = s
                break

        cs = ClassroomState(
            classroom=classroom,
            user=new_student,
            status=ClassroomState.APPROVED_STATUS
        )

        timestamp = utc_now()

        # Add student to classroom
        cs.save()
        add_permissions_to_classroom_students(classroom)

        self.assertTrue(Purchase.objects.filter(
            user=new_student,
            project=self.locked_projects.first(),
            permission=Purchase.VIEW_PERM).exists()
        )

        # Check that all of the student's moderators got a permission to the project.
        for cg in new_student.childguardian_guardian_set.all():
            p = Purchase.objects.filter(
                user=cg.guardian,
                project=self.locked_projects.first(),
                permission=Purchase.VIEW_PERM
            )
            self.assertTrue(p.exists())
            for purchase in p:
                self.assertGreaterEqual(purchase.added, timestamp)

        # Cleanup
        cs.delete()
        pic.delete()
        classroom.delete()
        Purchase.objects.filter(added__gte=timestamp).delete()
コード例 #18
0
 def _create_date_slug(self):
     """Prefixes the slug with the ``published_on`` date."""
     if not self.pk:
         # haven't saved this yet, so use today's date
         d = utc_now()
     elif self.published and self.published_on:
         # use the actual published on date
         d = self.published_on
     elif self.updated_on:
         # default to the last-updated date
         d = self.updated_on
     self.date_slug = u"{0}/{1}".format(d.strftime("%Y/%m/%d"), self.slug)
コード例 #19
0
    def post_process(self, paths, **options):
        last_modified_js_dt = utc_now() - datetime.timedelta(days=10000)

        for name, data in paths.items():
            if name.lower().endswith(".js"):
                storage, _ = data
                last_modified_js_dt = max(last_modified_js_dt,
                                          storage.get_modified_time(name))

            yield name, name, False

        cache.set(LAST_MOD_CACHE_KEY, str(last_modified_js_dt), None)
コード例 #20
0
def handle_dsn(original_dsn, report_headers):
    """
    Handle a delivery status notification idempotent

    @param headers : a python dict with all the headers of the DSN email.
    """
    ENVELOPE_FIELD = 'To'
    original_dsn = email.message_from_string(original_dsn)

    try:
        envelope = parseaddr(original_dsn[ENVELOPE_FIELD])[1]
    except ValueError:
        log.info('Reject unknown mail: {}'.format(
            original_dsn[ENVELOPE_FIELD]))
        return

    try:
        dsn_report = DSNParser(report_headers)
    except InvalidDSNError as e:
        log.info('Reject invalid DSN: {}'.format(str(e)))
        return

    date = utc_now()
    next_status = dsn_report.get_next_mailstatus()

    try:
        if not return_path_parser.is_valid(envelope):
            log.info('Reject invalid address format: {}'.format(envelope))
            return
        identifier = return_path_parser.get_uuid(envelope)
        mail = Mail.objects.get(identifier=identifier)
    except (Mail.DoesNotExist, ValueError):
        log.info('Reject unknown mail: {}'.format(envelope))
        return
    log.info('Logging new status {} for {}'.format(next_status, mail))
    try:
        ms, created = MailStatus.objects.get_or_create(
            mail=mail,
            creation_date=date,
            status=next_status,
            defaults={
                'raw_msg': dsn_report.msg,
                'status_code': dsn_report.esmtp_status
            })
    except django_fsm.TransitionNotAllowed as e:
        log.info('Reject forbidden dsn status transition '
                 '({}): {}\n{}'.format(next_status, mail.identifier, str(e)))
        return
    # If there is nothing left to send, change the state of the message !
    remaining = mail.message.mails.legit_for(mail.message).pending().count()
    if remaining == 0:
        mail.message.status = Message.SENT
        mail.message.save()
コード例 #21
0
ファイル: tasks.py プロジェクト: omni360/inspiration-edu-api
def logout_non_approved_users(days_to_wait):
    non_approved_users_list = IgniteUser.objects.filter(
                                   is_child=True,
                                   is_approved=False,
                                   added__gte=utc_now() - timedelta(days=days_to_wait)
                               ).values_list('pk', flat=True)
    if len(non_approved_users_list) > 0:
        sessions = Session.objects.all()
        for session in sessions:
            session_uid = session.get_decoded().get('_auth_user_id')
            if session_uid in non_approved_users_list:
                session.delete()

        Token.objects.filter(user__pk__in=non_approved_users_list).delete()
コード例 #22
0
def _helper_get_months_back_date_range(months_back=0):
    now = utc_now()
    # Get date at the beginning of the month
    gte_datetime = now - timedelta(days=now.day-1)
    # move back by the month
    for i in range(months_back):
        # Substruct one day to move to previous month
        gte_datetime = gte_datetime - timedelta(days=1)
        # Move back by the number of days there are in a calculated month but return one day to get to first one
        gte_datetime = gte_datetime - timedelta(days=calendar.mdays[gte_datetime.month] - 1)
    # Round the time
    gte_datetime = datetime(gte_datetime.year, gte_datetime.month, 1, tzinfo=now.tzinfo)
    # Calculate month forward
    lt_datetime = gte_datetime + timedelta(days=calendar.mdays[gte_datetime.month])
    return gte_datetime, lt_datetime
コード例 #23
0
ファイル: models.py プロジェクト: Vvnrck/remote-v8-site
 def update_task(task_assignment_id, result):
     assignment = TaskAssignment.objects.get(id=task_assignment_id)
     assignment.task.result = result
     assignment.task.computed = True
     assignment.last_update = utc_now()
     timedelta = (assignment.last_update - assignment.assignment_date).seconds
     if assignment.task.is_benchmark:
         assignment.worker.benchmark_result = timedelta
     else:
         benchmark = assignment.worker.benchmark_result
         assignment.worker.points += int(round(timedelta / benchmark, 0))
         assignment.task.points += assignment.worker.points
     assignment.task.save()
     assignment.save()
     assignment.worker.save()
コード例 #24
0
    def test_task_publish_ready_projects(self, mock_send):
        project = self._get_new_project_with_lessons()
        project.publish_mode = Project.PUBLISH_MODE_READY
        project.min_publish_date = utc_now() - timedelta(hours=1)
        project.save()
        project.registrations.create(user=get_user_model().objects.first())

        publish_ready_projects.run()

        project = Project.objects.get(pk=project.pk)
        self.assertEqual(project.publish_mode, Project.PUBLISH_MODE_PUBLISHED)
        self.assertEqual(project.publish_date, project.updated)
        self.assertEqual(project.registrations.count(), 0)

        self._check_notifications(project, None, Project.PUBLISH_MODE_PUBLISHED, Project.PUBLISH_MODE_READY, mock_send)
コード例 #25
0
ファイル: models.py プロジェクト: IlIlIlIlII/remote-v8-site
 def update_task(task_assignment_id, result):
     assignment = TaskAssignment.objects.get(id=task_assignment_id)
     assignment.task.result = result
     assignment.task.computed = True
     assignment.last_update = utc_now()
     timedelta = (assignment.last_update -
                  assignment.assignment_date).seconds
     if assignment.task.is_benchmark:
         assignment.worker.benchmark_result = timedelta
     else:
         benchmark = assignment.worker.benchmark_result
         assignment.worker.points += int(round(timedelta / benchmark, 0))
         assignment.task.points += assignment.worker.points
     assignment.task.save()
     assignment.save()
     assignment.worker.save()
    def test_update_permissions_called_when_student_added_to_classroom(self):
        
        timestamp = utc_now()
        
        classroom = Classroom(title='my classroom', owner=self.owner)
        classroom2 = Classroom(title='my classroom 2', owner=self.owner)
        classroom.save()
        classroom2.save()
        
        self.client.force_authenticate(self.owner)

        pic = ProjectInClassroom(project=self.locked_projects.first(), classroom=classroom, order=0)
        pic.save()

        new_student = get_user_model().objects.filter(
            is_child=False
        ).exclude(
            id__in=Purchase.objects.all().values_list('user_id', flat=True)
        ).first()

        ClassroomState(
            classroom=classroom2,
            user=new_student,
            status=ClassroomState.APPROVED_STATUS
        ).save()

        with mock.patch('api.tasks.add_permissions_to_classroom_students.delay') as my_mock:
            resp = self.client.put(reverse(
                'api:classroom-students-detail',  kwargs={
                    'classroom_pk': classroom.id,
                    'pk': new_student.id,
                }
            ))

            self.assertEqual(resp.status_code, 200)

            my_mock.assert_called_with(classroom)

        # Cleanup
        ClassroomState.objects.filter(classroom=classroom).delete()
        ProjectInClassroom.objects.filter(classroom=classroom).delete()
        classroom.delete()
        ClassroomState.objects.filter(classroom=classroom2).delete()
        classroom2.delete()
        Purchase.objects.filter(added__gte=timestamp).delete()
    def test_integrity_error_doesnt_cause_problems(self):

        timestamp = utc_now()
        
        classroom = Classroom(title='my classroom', owner=self.owner)
        classroom.save()

        pic = ProjectInClassroom(project=self.locked_projects.first(), classroom=classroom, order=0)
        pic.save()
        
        # Add all adult students with no purchases.
        students = get_user_model().objects.filter(
            is_child=False
        ).exclude(
            id__in=Purchase.objects.all().values_list('user_id', flat=True)
        ).distinct()
        classroom_states = [ClassroomState(
            classroom=classroom,
            user=s,
            status=ClassroomState.APPROVED_STATUS
        ) for s in students]

        # Add last student and
        [cs.save() for cs in classroom_states]

        # Patch Purchase.save() to raise an IntegrityError once.
        patcher = mock.patch('api.models.Purchase.save')
        my_mock = patcher.start()
        def side_effect(*args, **kwargs):
            patcher.stop()
            raise IntegrityError('boom')
        my_mock.side_effect = side_effect

        purchases_count = Purchase.objects.all().count()
        add_permissions_to_classroom_students(classroom)

        # Make sure that all of the purchases were added, but one.
        new_purchases = students.count() - 1
        self.assertEqual(purchases_count + new_purchases, Purchase.objects.all().count())

        # Cleanup
        [cs.delete() for cs in classroom_states]
        pic.delete()
        classroom.delete()
        Purchase.objects.filter(added__gte=timestamp).delete()
    def test_update_permissions_propagates_to_moderators(self):
        
        classroom = Classroom(title='my classroom', owner=self.owner)
        classroom.save()

        pic = ProjectInClassroom(project=self.locked_projects.first(), classroom=classroom, order=0)
        pic.save()
        
        # Add all potential students, but 1.
        new_student = ChildGuardian.objects.exclude(
            guardian=self.owner
        ).first().child
        cs = ClassroomState(
            classroom=classroom,
            user=new_student,
            status=ClassroomState.APPROVED_STATUS
        )

        timestamp = utc_now()

        # Add last student and
        cs.save()
        add_permissions_to_classroom_students(classroom)

        self.assertTrue(Purchase.objects.filter(
            user=new_student,
            project=self.locked_projects.first(),
            permission=Purchase.VIEW_PERM).exists()
        )

        for cg in new_student.childguardian_guardian_set.all():
            p = Purchase.objects.filter(
                user=cg.guardian,
                project=self.locked_projects.first(),
                permission=Purchase.VIEW_PERM
            )
            self.assertTrue(p.exists())
            for purchase in p:
                self.assertGreaterEqual(purchase.added, timestamp)

        # Cleanup
        cs.delete()
        pic.delete()
        classroom.delete()
        Purchase.objects.filter(added__gte=timestamp).delete()
コード例 #29
0
def company_current_price(company):
    if not is_market_open(company):
        return dict(is_open=False, price=None)

    ts = TimeSeries(key=settings.ALPHA_VANTAGE_API_KEY)

    time_series, meta_data = ts.get_daily(company.symbol)

    try:
        local_tz = pytz.timezone(meta_data['5. Time Zone'])
        date = local_tz.normalize(utc_now().astimezone(local_tz)).date()

        return dict(is_open=True,
                    price=time_series[date.isoformat()]['4. close'])
    except KeyError as e:
        logger.exception(e)

    return dict(is_open=True, price=None)
コード例 #30
0
    def _test_can_change_mode(self, project, user, to_mode, from_mode, mock_send):
        if user:
            self.client.force_authenticate(user)

        old_publish_mode = project.publish_mode
        if from_mode:
            project.publish_mode = from_mode
            project.save()

        old_min_publish_date = project.min_publish_date
        if to_mode == Project.PUBLISH_MODE_READY:
            project.min_publish_date = utc_now() + timedelta(days=1)
            project.save()
        elif to_mode == Project.PUBLISH_MODE_PUBLISHED:
            project.min_publish_date = None
            project.save()
            project.registrations.create(user=get_user_model().objects.first())
            self.assertGreater(project.registrations.count(), 0)

        resp = self.client.patch(
            reverse(self.api_change_mode_detail, kwargs={'pk': project.pk}),
            json.dumps({
                'publishMode': to_mode,
            }),
            content_type='application/json',
        )
        self.assertEqual(resp.status_code, 200)
        self.assertEqual(resp.data['publishMode'], to_mode)

        self._check_notifications(project, user, to_mode, from_mode, mock_send)

        # Re-get project
        project = Project.objects.get(pk=project.pk)
        self.assertEqual(project.publish_mode, to_mode)
        if to_mode == Project.PUBLISH_MODE_PUBLISHED:
            self.assertEqual(project.publish_date, project.updated)
            self.assertEqual(project.registrations.count(), 0)
        else:
            self.assertIsNone(project.publish_date)

        # Clean
        project.publish_mode = old_publish_mode
        project.min_publish_date = old_min_publish_date
        project.save()
コード例 #31
0
ファイル: tasks.py プロジェクト: omni360/inspiration-edu-api
 def get_templates_info(cls):
     '''Returns info dict on the mail templates {load_time, refresh_threshold_hours, is_stale, cur_time}.'''
     redis_conn = get_redis_connection('default')
     templates_refresh_threshold_hours = redis_conn.hget(cls.redis_hash_templates, 'refresh_threshold_hours')
     if not templates_refresh_threshold_hours:  #if not set, set default refresh threshold
         templates_refresh_threshold_hours = 24
         redis_conn.hset(cls.redis_hash_templates, 'refresh_threshold_hours', templates_refresh_threshold_hours)
     templates_refresh_threshold_hours = int(templates_refresh_threshold_hours)
     templates_load_time_str = redis_conn.hget(cls.redis_hash_templates, 'load_time')
     templates_refresh_threshold_timedelta = timedelta(hours=templates_refresh_threshold_hours)
     templates_load_time = parse_datetime(templates_load_time_str) if templates_load_time_str else None
     cur_time = utc_now()
     templates_is_stale = not templates_load_time or cur_time - templates_load_time > templates_refresh_threshold_timedelta
     return {
         'load_time': templates_load_time_str,
         'refresh_threshold_hours': templates_refresh_threshold_hours,
         'is_stale': templates_is_stale,
         'cur_time': str(cur_time),
     }
コード例 #32
0
    def _make_project_with_lessons_and_steps(self, num_lessons=2, num_steps=3, owner=None):
        owner = owner or self.owner_user
        project = Project.objects.create(
            owner=owner,
            title='Testing 101',
            publish_mode=Project.PUBLISH_MODE_PUBLISHED,
            publish_date=utc_now(),
            description='Learn how to test Django applications using Python\'s unittest',
            duration=45,
            banner_image='http://placekitten.com/2048/640/',
            card_image='http://placekitten.com/1024/768/',
            age=Project.AGES[0][0],
            difficulty=Project.DIFFICULTIES[0][0],
            license=Project.LICENSES[0][0],
            tags='3D-Design Tools,Printing',
            ngss=[Project.NGS_STANDARDS[0][0], Project.NGS_STANDARDS[1][0]],
            ccss=[Project.CCS_STANDARDS[0][0], Project.CCS_STANDARDS[1][0]],
            subject=[Project.SUBJECTS[0][0], Project.SUBJECTS[1][0]],
            technology=[Project.TECHNOLOGY[0][0], Project.TECHNOLOGY[1][0]],
            grades_range=[Project.GRADES[0][0], Project.GRADES[1][0]],
            skills_acquired=['3D-printing', '3D-modeling'],
            learning_objectives=['Mesh', 'Shaders'],
            four_cs_creativity='<p>Creativity</p>',
            four_cs_critical='<p>Critical</p>',
            four_cs_communication='<p>Communication</p>',
            four_cs_collaboration='<p>Collaboration</p>',
        )

        for x in range(num_lessons):
            lesson = Lesson.objects.create(
                project=project,
                title='Lesson 10%s' % (x,),
                application='tinkercad',
                duration=30,
            )
            for y in range(num_steps):
                step = Step.objects.create(
                    lesson=lesson,
                    title='Step of lesson - %s' % (y,),
                    description='Move to the next step...',
                )
        return project
    def test_update_permissions_called_when_project_added_to_classroom(self):
        
        timestamp = utc_now()
        
        classroom = Classroom(title='my classroom', owner=self.owner)
        classroom.save()
        
        # Add all adult students with no purchases.
        students = get_user_model().objects.filter(
            is_child=False
        ).exclude(
            id__in=Purchase.objects.all().values_list('user_id', flat=True)
        ).distinct()

        classroom_states = [ClassroomState(
            classroom=classroom,
            user=s,
            status=ClassroomState.APPROVED_STATUS
        ) for s in students]
        [cs.save() for cs in classroom_states]

        self.client.force_authenticate(self.owner)

        with mock.patch('api.tasks.add_permissions_to_classroom_students.delay') as my_mock:
            resp = self.client.put(
                reverse('api:classroom-project-detail', kwargs={
                    'classroom_pk': classroom.id,
                    'pk': self.locked_projects.first().id,
                }),
                json.dumps({'order': 0}, cls=DjangoJSONEncoder),
                content_type='application/json',
            )

            self.assertEqual(resp.status_code, 200)

            my_mock.assert_called_with(classroom)

        # Cleanup
        ClassroomState.objects.filter(classroom=classroom).delete()
        ProjectInClassroom.objects.filter(classroom=classroom).delete()
        classroom.delete()
        Purchase.objects.filter(added__gte=timestamp).delete()
コード例 #34
0
    def member_data_v2_by_oxygen_id(self, oxygen_id):
        #prepare params:
        oxygen_consumer_key = settings.OXYGEN_CONSUMER_KEY
        ts_datetime = utc_now()
        params = {}
        params['ts'] = ts_datetime.strftime('%Y-%m-%d %H:%M:%S')
        params['afc'] = self.sparkdrive_afc
        params['member_code'] = binascii.hexlify((self.sparkdrive_admin_member_id or '') + '#' + params['ts'])
        params['hash'] = hashlib.sha256(params['afc'] + params['member_code'] + params['ts'] + oxygen_consumer_key).hexdigest()

        #get member data by oxygen id:
        sparkdrive_resp = requests.get(
            self.sparkdrive_api2 + '/admin/members/oxygen/%s?%s' %(oxygen_id, urllib.urlencode(params)),
            headers=self._get_request_headers(),
        )
        self._parse_sparkdrive_response(sparkdrive_resp)

        if sparkdrive_resp.status_code == 200:
            return sparkdrive_resp.data.get('member')
        else:
            raise self.SparkDriveApiError('SparkDrive member data v2 by oxygen ID.', spark_error=sparkdrive_resp.data, spark_status_code=sparkdrive_resp.status_code)
コード例 #35
0
    def setUp(self):
        # patch the utc_now function so it's return value is essentiall cashed
        self.now = utc_now()
        config = {'return_value': self.now}
        self.utc_now_patcher = patch('blargg.models.utc_now', **config)
        self.utc_now_patcher.start()

        username = ''.join([choice(ascii_letters) for i in range(10)])
        User = get_user_model()
        user = User.objects.create(
            username=username,
            password='******'.format(username)
        )
        self.entry = Entry(
            site=Site.objects.get(pk=settings.SITE_ID),
            author=user,
            title="Test Entry",
            raw_content="Test Content",
            tag_string="foo, bar, baz",
        )
        self.entry.save()
コード例 #36
0
    def test_project_change_mode_ready_to_publish(self, mock_send):
        project = self._get_new_project_with_lessons()

        # Owner - edit->review

        self.client.force_authenticate(self.owner_user)
        min_publish_date = utc_now() + timedelta(days=1)
        resp = self.client.patch(
            reverse(self.api_change_mode_detail, kwargs={'pk': project.pk}),
            json.dumps({
                'publishMode': Project.PUBLISH_MODE_REVIEW,
                'minPublishDate': min_publish_date.isoformat(),
            }),
            content_type='application/json',
        )
        self.assertEqual(resp.status_code, 200)
        self.assertEqual(resp.data['publishMode'], Project.PUBLISH_MODE_REVIEW)
        self.assertEqual(parse_datetime(resp.data['minPublishDate']), min_publish_date)

        project = Project.objects.get(pk=project.pk)
        self.assertEqual(project.publish_mode, Project.PUBLISH_MODE_REVIEW)
        self.assertEqual(project.min_publish_date, min_publish_date)
        self.assertIsNone(project.publish_date)

        # Reviewer - review->published (actual moves to ready for publish)

        self.client.force_authenticate(self.reviewer_user)
        resp = self.client.patch(
            reverse(self.api_change_mode_detail, kwargs={'pk': project.pk}),
            json.dumps({
                'publishMode': Project.PUBLISH_MODE_PUBLISHED,
            }),
            content_type='application/json',
        )
        self.assertEqual(resp.status_code, 200)
        self.assertEqual(resp.data['publishMode'], Project.PUBLISH_MODE_READY)

        project = Project.objects.get(pk=project.pk)
        self.assertEqual(project.publish_mode, Project.PUBLISH_MODE_READY)
        self.assertIsNone(project.publish_date)
コード例 #37
0
ファイル: utils.py プロジェクト: prameet-jain/remo
def count_user_ng_reports(user, current_streak=False,
                          longest_streak=False, period=0):
    """Return the number of reports of a user over

    a period of time. If current_streak is True return the
    current streak of a user. Arg period expects weeks
    eg 2 means 2 * 7 = 14 days.
    """
    end_period = utc_now()
    start_period = datetime(2011, 01, 01)

    if current_streak:
        start_period = user.userprofile.current_streak_start
    elif longest_streak:
        start_period = user.userprofile.longest_streak_start
        end_period = user.userprofile.longest_streak_end
    elif period > 0:
        start_period = get_date(-(period * 7))

    query = user.ng_reports.filter(report_date__range=(start_period,
                                                       end_period))

    return query.count()
コード例 #38
0
def get_current_time():
    now = utc_now()
    return now if is_naive(now) else localtime(now)
コード例 #39
0
ファイル: models.py プロジェクト: prameet-jain/remo
 def is_future_report(self):
     if self.report_date > utc_now().date():
         return True
     return False
コード例 #40
0
ファイル: models.py プロジェクト: IlIlIlIlII/remote-v8-site
 def _assign_task(task, worker):
     assignment, _ = TaskAssignment.objects.get_or_create(
         worker=worker, task=task, assignment_date=utc_now())
     return assignment
コード例 #41
0
ファイル: helpers.py プロジェクト: prameet-jain/remo
def is_date_today(date):
    if date == utc_now().date():
        return True
    return False
コード例 #42
0
def dashboard(request):
    """Dashboard view."""
    user = request.user
    args = {}

    # Mozillians block
    if user.groups.filter(name='Mozillians').exists():
        return dashboard_mozillians(request, user)

    # Reps block
    q_closed = Q(status='RESOLVED') | Q(status='VERIFIED')
    budget_requests = (Bug.objects.filter(
        component='Budget Requests').exclude(q_closed))
    swag_requests = (Bug.objects.filter(
        component='Swag Requests').exclude(q_closed))
    mentorship_requests = (Bug.objects.filter(
        component='Mentorship').exclude(q_closed))
    cit_requests = (Bug.objects.filter(
        component='Community IT Requests').exclude(q_closed))
    planning_requests = (Bug.objects.filter(
        component='Planning').exclude(q_closed))

    today = date.today()
    # NG Reports
    if waffle.flag_is_active(request, 'reports_ng_report'):
        if user.groups.filter(name='Rep').exists():
            args['ng_reports'] = (user.ng_reports.filter(
                report_date__lte=today).order_by('-report_date'))
            args['today'] = utc_now()

        if user.groups.filter(name='Mentor').exists():
            args['mentees_ng_reportees'] = User.objects.filter(
                ng_reports__isnull=False, ng_reports__mentor=user).distinct()

        if user.groups.filter(Q(name='Admin') | Q(name='Council')).exists():
            args['all_ng_reportees'] = User.objects.filter(
                ng_reports__isnull=False).distinct()

    # Old reporting system and dashboard data
    if user.groups.filter(name='Rep').exists():
        args['monthly_reports'] = get_reports_for_year(
            user,
            start_year=2011,
            end_year=today.year,
            permission=REPORTS_PERMISSION_LEVEL['owner'])

    my_q = (Q(cc=user) | Q(creator=user))
    my_q_assigned = (my_q | Q(assigned_to=user))
    my_mentees = User.objects.filter(userprofile__mentor=user,
                                     userprofile__registration_complete=True)

    args['my_budget_requests'] = budget_requests.filter(my_q).distinct()
    args['my_swag_requests'] = swag_requests.filter(my_q).distinct()

    if user.groups.filter(name='Mentor').exists():
        args['mentees_budget_requests'] = (budget_requests.filter(
            creator__in=my_mentees).distinct())
        args['mentees_swag_requests'] = (swag_requests.filter(
            creator__in=my_mentees).distinct())
        my_mentorship_requests = mentorship_requests.filter(my_q_assigned)
        my_mentorship_requests = my_mentorship_requests.order_by('whiteboard')
        args['my_mentorship_requests'] = my_mentorship_requests.distinct()
        args['mentees_reports_list'] = (Report.objects.filter(
            mentor=user).order_by('-created_on').distinct()[:20])
        args['mentees_reports_grid'] = get_mentee_reports_for_month(user)
        args['mentees_emails'] = (my_mentees.values_list(
            'first_name', 'last_name', 'email') or None)
        args['email_mentees_form'] = forms.EmailUsersForm(my_mentees)

    if user.groups.filter(Q(name='Admin') | Q(name='Council')).exists():
        args['all_budget_requests'] = budget_requests.all()[:20]
        args['all_swag_requests'] = swag_requests.all()[:20]
        args['my_cit_requests'] = cit_requests
        args['my_planning_requests'] = planning_requests
        args['all_reports'] = (
            Report.objects.all().order_by('-created_on')[:20])
    else:
        args['my_planning_requests'] = (
            planning_requests.filter(my_q_assigned).distinct())

    if user.groups.filter(name='Admin').exists():
        args['is_admin'] = True
        reps = User.objects.filter(groups__name='Rep')
        args['reps_without_mentors'] = reps.filter(
            userprofile__registration_complete=True, userprofile__mentor=None)
        args['reps_without_profile'] = reps.filter(
            userprofile__registration_complete=False)

    return render(request, 'dashboard_reps.html', args)
コード例 #43
0
 def save(self, *args, **kwargs):
     if not self.date_created:
         self.date_created = utc_now()
     self.date_updated = utc_now()
     super(ModificationTrackingMixin, self).save(*args, **kwargs)