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),
]
