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()
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)
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)
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]))
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()
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)
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())
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)
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
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)
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())
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)
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()
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)
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)
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()
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()
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
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_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)
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()
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)
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()
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), }
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()
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)
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()
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)
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()
def get_current_time(): now = utc_now() return now if is_naive(now) else localtime(now)
def is_future_report(self): if self.report_date > utc_now().date(): return True return False
def _assign_task(task, worker): assignment, _ = TaskAssignment.objects.get_or_create( worker=worker, task=task, assignment_date=utc_now()) return assignment
def is_date_today(date): if date == utc_now().date(): return True return False
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)
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)