class TaskIssue(models.Model): title = models.CharField(max_length=200, null=True, blank=True) level = models.CharField(max_length=50, null=True, blank=True) task = models.ForeignKey(Task, on_delete=models.CASCADE) type = models.ForeignKey(TaskIssueType, on_delete=models.CASCADE, null=True, blank=True) power_state = models.ForeignKey(PowerState, null=True, blank=True, on_delete=models.CASCADE) device_driver = JSONField(null=True, blank=True) function = models.CharField(max_length=100, null=True, blank=True) description = TextField(null=True, blank=True) recover_time = DurationField(null=True, blank=True) occur_time = DurationField(null=True, blank=True) add_time = models.DateTimeField(blank=True, null=True, default=datetime.datetime.now()) class Meta: managed = True db_table = 'task_issue' def __repr__(self) -> str: return f'TaskIssue {self.id}' def __str__(self) -> str: return self.__repr__()
class Drill(TimeStampedModel): """A drill""" name = models.CharField(_("Name of Drill"), max_length=150, unique=True) slug = AutoSlugField(populate_from="name") description = models.TextField(null=True, blank=True) image = models.ImageField(null=True, blank=True) duration = DurationField(null=True, blank=True, default=datetime.timedelta()) @property def image_url(self) -> typing.Optional[str]: if self.image: return self.image.url return None def get_absolute_url(self) -> str: """Get url for drill's detail view. Returns: str: URL for dril detail. """ return reverse("drills:detail", kwargs={"slug": self.slug}) def __str__(self) -> str: """String representation of a drill.""" return str(self.slug)
def lead_device_type_totals(user: User, date_from: date, date_to: date, projects: list = None, label_type=None, label_values=None, os_groups=None, browser_groups=None, traffic_channels=None): leads_qs = Lead.objects.filter(pixel__project__user=user) leads_qs = _apply_lead_common_filters(leads_qs, date_from, date_to, projects, label_type, label_values, os_groups, browser_groups, traffic_channels) leads_qs = leads_qs.annotate(lead_duration=ExpressionWrapper( F('created') - F('session_started'), output_field=DurationField())) leads_qs = leads_qs.annotate(group_name=Case( When(device_model__device_type__category__in=(DeviceType.PHONE, DeviceType.TABLET), then=Value('Mobile')), When(device_model__device_type__category=(DeviceType.DESKTOP), then=Value('Desktop')), default=Value(_('Unknown')), output_field=CharField())) leads_qs = leads_qs.values('group_name') leads_qs = leads_qs.annotate(leads_count=Count('id')) leads_qs = leads_qs.order_by('group_name') return leads_qs
def lead_duration_by_period(user: User, date_from: date, date_to: date, groups: list = None, projects: list = None, label_type=None, label_values=None, os_groups=None, browser_groups=None, traffic_channels=None): leads_qs = Lead.objects.filter(pixel__project__user=user) leads_qs = _apply_lead_common_filters(leads_qs, date_from, date_to, projects, label_type, label_values, os_groups, browser_groups, traffic_channels) leads_qs = leads_qs.annotate(lead_duration=ExpressionWrapper( F('created') - F('session_started'), output_field=DurationField())) leads_qs = leads_qs.annotate(group_name=_lead_duration_groups_case()) if groups: leads_qs = leads_qs.filter(group_name__in=groups) scale_period = get_scale_period(date_from, date_to) leads_qs = leads_qs.annotate( created_period=_leads_period_unit_expr(scale_period)) leads_qs = leads_qs.values('group_name', 'created_period') leads_qs = leads_qs.annotate(leads_count=Count('id')) leads_qs = leads_qs.order_by('created_period', 'group_name') return leads_qs
def _episodes_queryset(podcast: Podcast) -> QuerySet[Podcast]: """ Builds a query set that should give out episodes of a podcast according to the following criteria: if not older than 7 days: On any day else if not older than 30 days: On every 7th day else if older than 30 days: On every 28th day """ now = local_now() today = local_today() isocalendar_today = today.isocalendar() standard_day_of_year_today = isocalendar_today[1] * 7 + isocalendar_today[2] last_available_cutoff = now - dt.timedelta(days=5) return (podcast.episodes.exclude(spotify_id=None).filter( Q(available=True) | Q(last_available_date_time__gt=last_available_cutoff) ).annotate( # Determine general age age_td=ExpressionWrapper( now - F("publication_date_time"), output_field=DurationField(), ), # Calculate something akin to "day of year" using the ISO calendar # and take modulo 28 for filtering standard_day_of_year_modulo=ExpressionWrapper( Cast( F("publication_date_time__week") * 7 + F("publication_date_time__iso_week_day"), IntegerField(), ) % 28, output_field=IntegerField(), ), ).filter( # New episodes every day Q(age_td__lte=dt.timedelta(days=7)) # In first month every 7 days (roughly, some weekdays might be more busy) | (Q(age_td__lte=dt.timedelta(days=30)) & Q(publication_date_time__iso_week_day=isocalendar_today[2])) # After that on every 28th day | (Q(age_td__gt=dt.timedelta(days=30)) & Q(standard_day_of_year_modulo=(standard_day_of_year_today % 28)))) )
class Flavor(Model): name = CharField(max_length=255) label = CharField(max_length=255) parent = ForeignKey("self", blank=True, null=True, on_delete=SET_NULL) float_value = FloatField(blank=True, null=True) decimal_value = DecimalField(blank=True, null=True, max_digits=10, decimal_places=2) uuid = UUIDField(default=uuid.uuid4) datetime = DateTimeField(blank=True, null=True) date = DateField(blank=True, null=True) time = TimeField(blank=True, null=True) duration = DurationField(blank=True, null=True) def __str__(self): return self.name
def get_events_per_day(self) -> list[dict[str, int]]: """Get event count by hour in the last day, fill with zeros""" date_from = now() - timedelta(weeks=4) result = (self.filter(created__gte=date_from).annotate( age=ExpressionWrapper( now() - F("created"), output_field=DurationField())).annotate( age_days=ExtractDay("age")).values("age_days").annotate( count=Count("pk")).order_by("age_days")) data = Counter({int(d["age_days"]): d["count"] for d in result}) results = [] _now = now() for day in range(0, -30, -1): results.append({ "x_cord": time.mktime((_now + timedelta(days=day)).timetuple()) * 1000, "y_cord": data[day * -1], }) return results
class TrackPosition(models.Model): user = models.ForeignKey( "auth.User", on_delete=models.CASCADE, related_name='+', verbose_name=u"用户", ) chapter = models.ForeignKey(Chapter, on_delete=models.CASCADE, verbose_name=u"章节") # position = models.IntegerField(verbose_name=u"播放位置") position = DurationField(verbose_name=u"播放位置") # date = models.DateTimeField(auto_now_add=True, blank=True) time = models.DateTimeField(default=django.utils.timezone.now, blank=True, verbose_name=u"时间") def __str__(self): return u'%s' % self.position class Meta: verbose_name = u'文件位置' verbose_name_plural = u'文件位置' def get_absolute_url(self): """ URLs for blog posts can either be just their slug, or prefixed with a portion of the post's publish date, controlled by the setting ``BLOG_URLS_DATE_FORMAT``, which can contain the value ``year``, ``month``, or ``day``. Each of these maps to the name of the corresponding urlpattern, and if defined, we loop through each of these and build up the kwargs for the correct urlpattern. The order which we loop through them is important, since the order goes from least granular (just year) to most granular (year/month/day). """ self.slug = self.chapter.book.slug self.no = str(self.chapter.no) self.pos = str(self.position) # return "/frontend/bookdetail/%s/%s/$s" % (self.chapter.book.slug, self.no, self.pos) return "/frontend/bookdetail/" + self.slug + "/" + self.no + "/" + self.pos
def get_events_per_1h(**filter_kwargs) -> list[dict[str, int]]: """Get event count by hour in the last day, fill with zeros""" date_from = now() - timedelta(days=1) result = (Event.objects.filter( created__gte=date_from, **filter_kwargs).annotate(age=ExpressionWrapper( now() - F("created"), output_field=DurationField())).annotate( age_hours=ExtractHour("age")).values("age_hours").annotate( count=Count("pk")).order_by("age_hours")) data = Counter({int(d["age_hours"]): d["count"] for d in result}) results = [] _now = now() for hour in range(0, -24, -1): results.append({ "x_cord": time.mktime((_now + timedelta(hours=hour)).timetuple()) * 1000, "y_cord": data[hour * -1], }) return results
def lead_os_totals(user: User, date_from: date, date_to: date, is_mobile, projects: list = None, label_type=None, label_values=None, os_groups=None, browser_groups=None, traffic_channels=None): leads_qs = Lead.objects.filter(pixel__project__user=user) leads_qs = _apply_lead_common_filters(leads_qs, date_from, date_to, projects, label_type, label_values, os_groups, browser_groups, traffic_channels) leads_qs = leads_qs.filter(os_version__family__group__is_mobile=is_mobile) leads_qs = leads_qs.annotate(lead_duration=ExpressionWrapper( F('created') - F('session_started'), output_field=DurationField())) leads_qs = leads_qs.annotate(group_name=Coalesce( F('os_version__family__group__name'), Value(_('Unknown')))) leads_qs = leads_qs.values('group_name') leads_qs = leads_qs.annotate(leads_count=Count('id')) leads_qs = leads_qs.order_by('group_name') return leads_qs
def _load_period_ipstat(fill_date: date, period: timedelta): end_time = timezone.make_aware( time(hour=23, minute=59, second=59, microsecond=999999)) end_date = datetime.combine(fill_date, end_time) start_date = (end_date - period).replace(hour=0, minute=0, second=0, microsecond=0) return Lead.objects \ .filter(session_started__range=(start_date, end_date)) \ .filter(ip_addr__isnull=False) \ .values('ip_addr', 'geo', 'geo__country', 'geo__postal_code', 'provider') \ .annotate(s_cnt=Count('id')) \ .annotate(s_time=Sum(ExpressionWrapper( Coalesce('created', 'last_event_time') - F('session_started'), output_field=DurationField()))) \ .annotate(s0_cnt=Count(Case( When(created__isnull=True, then=F('id')), default=None, output_field=UUIDField()))) \ .annotate(s_beg=Cast(Avg( Cast(F('session_started'), output_field=TimeField()) ), output_field=TimeField())) \ .annotate(user_ids=ArrayAgg('pixel__project__user__id', distinct=True))\ .annotate(cnt_dev=Count('device_id'))
def post(self, request, format=None): days = request.data.get('days', 10) all_days = request.data.get('download_all', False) today = timezone.now() queryset = ProductExpiry.objects.filter(datetime__gte=today) if not all_days: end_dt = today + timedelta(days=days) queryset = queryset.filter(datetime__lte=end_dt) queryset = queryset.order_by('datetime') \ .select_related('product') \ .annotate(diff_days=ExpressionWrapper(F('datetime') - today, output_field=DurationField()), total_value=ExpressionWrapper(F('product__stock') * F('product__price'), output_field=DecimalField())) if not os.path.exists('temp_files'): os.makedirs('temp_files') file_name = f'temp_files/{uuid4()}.xlsx' workbook = xlsxwriter.Workbook(file_name) worksheet = workbook.add_worksheet() headers = ['Sl.no', 'Product', 'MRP', 'Quantity', 'Total MRP Value', 'Expiry Day', 'No of Days for Expiry'] row = 0 col = 0 for header in headers: worksheet.write(row, col, header) col = col + 1 values = queryset.values('product__name', 'product__price', 'product__stock', 'datetime', 'diff_days', 'total_value') row = 1 col = 0 for entry in values: worksheet.write(row, col, row) worksheet.write(row, col + 1, entry['product__name']) worksheet.write(row, col + 2, entry['product__price']) worksheet.write(row, col + 3, entry['product__stock']) worksheet.write(row, col + 4, entry['total_value']) worksheet.write(row, col + 5, entry['datetime'].strftime('%d/%m/%y')) worksheet.write(row, col + 6, entry['diff_days'].days) row += 1 workbook.close() with open(file_name, 'rb') as fi: fl = File(fi, name=os.path.basename(fi.name)) report = ExpiryReport.objects.create(user=self.request.user, file=fl, no_of_days=days) try: os.remove(file_name) except OSError: pass return Response(data=ExpiryReportSerializer(report, context={'request': self.request}).data, status=status.HTTP_201_CREATED)
class Migration(migrations.Migration): dependencies = [ ('user', '0034_user_sso_id'), ] operations = [ migrations.CreateModel( name='Question', fields=[ ('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')), ('content', models.CharField(max_length=256)), ], ), migrations.CreateModel( name='Training', fields=[ ('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')), ('slug', models.SlugField(max_length=20, unique=True)), ( 'status', models.PositiveSmallIntegerField( choices=[(0, 'REVIEW'), (1, 'WITHDRAWN'), (2, 'REJECTED'), (3, 'ACCEPTED')], default=TrainingStatus(0), ), ), ( 'completion_report', models.FileField( blank=True, upload_to=get_training_path, validators=[django.core.validators.FileExtensionValidator(['pdf'], 'File must be a pdf.')], ), ), ('completion_report_url', models.URLField(blank=True)), ('application_datetime', models.DateTimeField(auto_now_add=True)), ('process_datetime', models.DateTimeField(null=True)), ('reviewer_comments', models.CharField(max_length=512)), ( 'reviewer', models.ForeignKey( null=True, on_delete=django.db.models.deletion.SET_NULL, related_name='reviewed_training', to=settings.AUTH_USER_MODEL, ), ), ], ), migrations.CreateModel( name='TrainingType', fields=[ ('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')), ('name', models.CharField(max_length=128)), ('home_page', models.URLField(blank=True)), ('description', SafeHTMLField()), ('valid_duration', DurationField(null=True)), ( 'required_field', models.PositiveSmallIntegerField( choices=[(0, 'DOCUMENT'), (1, 'URL')], default=RequiredField(0) ), ), ('questions', models.ManyToManyField(related_name='training_types', to='user.Question')), ], ), migrations.CreateModel( name='TrainingQuestion', fields=[ ('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')), ('answer', models.NullBooleanField()), ('question', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, to='user.Question')), ( 'training', models.ForeignKey( on_delete=django.db.models.deletion.CASCADE, related_name='training_questions', to='user.Training', ), ), ], ), migrations.AddField( model_name='training', name='training_type', field=models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, to='user.TrainingType'), ), migrations.AddField( model_name='training', name='user', field=models.ForeignKey( on_delete=django.db.models.deletion.CASCADE, related_name='training', to=settings.AUTH_USER_MODEL ), ), migrations.AlterField( model_name='credentialapplication', name='training_completion_report', field=models.FileField( upload_to=get_training_path, null=True, validators=[django.core.validators.FileExtensionValidator(['pdf'], 'File must be a pdf.')] ) ), migrations.AlterField( model_name='credentialapplication', name='training_course_name', field=models.CharField( max_length=100, null=True, validators=[validate_alphaplusplus] ) ), migrations.RunPython(migrate_forward, migrate_backward), ]