def test_float(self):
FloatModel.objects.create(f1=-27.5, f2=0.33)
obj = FloatModel.objects.annotate(f1_floor=Floor('f1'), f2_floor=Floor('f2')).first()
self.assertIsInstance(obj.f1_floor, float)
self.assertIsInstance(obj.f2_floor, float)
self.assertEqual(obj.f1_floor, math.floor(obj.f1))
self.assertEqual(obj.f2_floor, math.floor(obj.f2))
def test_decimal(self):
DecimalModel.objects.create(n1=Decimal('-12.9'), n2=Decimal('0.6'))
obj = DecimalModel.objects.annotate(n1_floor=Floor('n1'), n2_floor=Floor('n2')).first()
self.assertIsInstance(obj.n1_floor, Decimal)
self.assertIsInstance(obj.n2_floor, Decimal)
self.assertEqual(obj.n1_floor, Decimal(math.floor(obj.n1)))
self.assertEqual(obj.n2_floor, Decimal(math.floor(obj.n2)))
def test_decimal(self):
DecimalModel.objects.create(n1=Decimal("-12.9"), n2=Decimal("0.6"))
obj = DecimalModel.objects.annotate(
n1_floor=Floor("n1"), n2_floor=Floor("n2")
).first()
self.assertIsInstance(obj.n1_floor, Decimal)
self.assertIsInstance(obj.n2_floor, Decimal)
self.assertEqual(obj.n1_floor, Decimal(math.floor(obj.n1)))
self.assertEqual(obj.n2_floor, Decimal(math.floor(obj.n2)))
def test_integer(self):
IntegerModel.objects.create(small=-20, normal=15, big=-1)
obj = IntegerModel.objects.annotate(
small_floor=Floor('small'),
normal_floor=Floor('normal'),
big_floor=Floor('big'),
).first()
self.assertIsInstance(obj.small_floor, int)
self.assertIsInstance(obj.normal_floor, int)
self.assertIsInstance(obj.big_floor, int)
self.assertEqual(obj.small_floor, math.floor(obj.small))
self.assertEqual(obj.normal_floor, math.floor(obj.normal))
self.assertEqual(obj.big_floor, math.floor(obj.big))
def make_priority_now(modeladmin, request, queryset):
# pylint: disable=unused-argument
offset = Status.state_offset
priority = datetime_to_int(now())
calculation = (
Floor(F(field) / offset, output_field=IntegerField()) * offset +
priority * 10 + F(field) % 10)
kwargs = {field: calculation}
queryset.update(**kwargs)
def checkBrokerRate(brokerid, total, ordertype, user):
tax = 1.096500
rate_value = BrokerRateRule.objects.filter(
user=user,
broker=brokerid,
ordertype=ordertype,
greaterthan__lte=total,
lessthan__gte=total,
).get()
return (Floor(rate_value.rate * tax))
def find_range_explist(group, page, limit, hide_ids):
'''获取某一个特定范围的实验列表，而不是全部'''
l = (page - 1) * limit # 注意page是从1开始的
r = page * limit
# 先排除删除的id，再排序，再取区间
# 第一个排序把先运行的实验放到后面
# 第二个排序把异常终止的实验（state=3）放到后面
return group.experiments.exclude(id__in=hide_ids).order_by(
Floor(F("state") / 3), "-start_time")[l:r]
def changelist_view(self, request, extra_context=None):
response = super().changelist_view(
request,
extra_context=extra_context,
)
try:
qs = response.context_data['cl'].queryset
except (AttributeError, KeyError):
return response
metrics = {
'total_containers':
Count('container', output_field=FloatField()),
'total_equipments':
Count('che', distinct=True, output_field=FloatField()),
'total_handling_time':
Max('che__kind__handling_time') * F('total_containers'),
'transportation_time':
Max('che__kind__trans_time') * F('total_equipments'),
'total_minutes':
F('total_handling_time') + F('transportation_time'),
'mod_minute':
Floor(F('total_minutes') / 60),
'total_hours':
Floor(F('total_minutes') / 60)
}
reports = qs.values('terminal', 'rent_date__date',
'che__kind').annotate(**metrics).order_by(
'terminal', 'rent_date__date', 'che__kind')
for r in reports:
mod_minute = r['total_minutes'] % 60
hours = math.floor(r['total_minutes'] / 60)
hours = hours + (0.5 if mod_minute > 0 and mod_minute < 30 else 0)
hours = hours + (1 if mod_minute >= 30 else 0)
r['mod_minute'] = mod_minute
r['total_hours'] = hours
response.context_data['summary'] = list(reports)
return response
def for_floored_interval(self, start=None, end=None, interval=60):
if end == None:
end = datetime.datetime.now(tz=pytz.utc)
if start == None:
start = datetime.datetime.now(tz=pytz.utc) - datetime.timedelta(
days=1)
return self.filter(
timestamp__range=(start, end)).order_by('timestamp').annotate(
unix=Floor(Extract('timestamp', 'epoch') / interval) *
interval,
time=Func(F('unix'),
function="TO_TIMESTAMP",
output_field=models.DateTimeField()),
)
def weight(self, min=settings.WEIGHT_MIN, max=settings.WEIGHT_MAX):
"""
Add a ``weight`` integer field to objects, weighting the ``count``
between ``min`` and ``max``.
Suitable for use with a tag cloud
"""
# Ignoring PEP 8 intentionally regarding conflict of min/max keywords -
# concerns are outweighed by clarity of function argument names.
# Weight is the count scaled to the min/max bounds
# weight = ( (count * (max - min)) / max_count ) + min
scale = int(max) - int(min)
max_count = self.model.objects.aggregate(Max("count"))["count__max"] or 0
qs = self.annotate(weight=(Floor(F("count") * scale) / max_count) + int(min))
return qs
def get(self, request):
Book.objects.update(
raters=Coalesce(
Subquery(
Book.objects.filter(id=OuterRef("id")).annotate(
c=Count("user_ratings__id")).values("c")[:1]),
0,
),
avg_ratings=Coalesce(
Subquery(
Book.objects.filter(id=OuterRef("id")).annotate(avg=Floor(
Avg("user_ratings__rate"))).values("avg")[:1]),
0,
),
)
return HttpResponseRedirect(request.META.get("HTTP_REFERER", "/"))
def weight(self, min=settings.WEIGHT_MIN, max=settings.WEIGHT_MAX):
"""
Add a ``weight`` integer field to objects, weighting the ``count``
between ``min`` and ``max``.
Suitable for use with a tag cloud
"""
# Ignoring PEP 8 intentionally regarding conflict of min/max keywords -
# concerns are outweighed by clarity of function argument names.
# Django 2.2 supports Floor
if Floor is not None:
# Weight is the count scaled to the min/max bounds
# weight = ( (count * (max - min)) / max_count ) + min
scale = int(max) - int(min)
max_count = self.model.objects.aggregate(
Max("count"))["count__max"] or 0
# Django 2.2
qs = self.annotate(weight=(Floor(F("count") * scale) / max_count) +
int(min))
else:
# Build SQL
template = ("%(floor)s((count*%(upper)d)/"
"(SELECT NULLIF(MAX(count), 0) FROM %(table)s)"
")+%(lower)d")
data = {
"floor": "FLOOR",
"upper": int(max - min),
"lower": int(min),
"table": '"%s"' % self.model._meta.db_table,
}
# Sqlite doesn't support FLOOR, but that's ok because it does it anyway
if connection.vendor == "sqlite":
data["floor"] = ""
# MySQL doesn't support double quoted tablenames, use backticks instead
if connection.vendor == "mysql":
data["table"] = "`%s`" % self.model._meta.db_table
# Perform query and add it as `weight`
qs = self.extra(select={"weight": template % data})
return qs
def univ_region_result(request):
template = "statistic/univ_region_result.html"
entrance_year_qs = Student.objects.values('entrance_year').order_by(
'entrance_year').distinct()
major_group_qs = MajorGroup.objects.order_by('major_group').distinct()
univ_region_qs = UnivRegion.objects.order_by('univ_region').distinct()
entrance_year_query = request.GET.get('entrance_year')
major_group_query = request.GET.get('major_group')
univ_region_query = request.GET.get('univ_region')
admission1_query = request.GET.get('admission1')
#계열, 대학지역기준 등급분포(column chart)
grade_list = []
grade_freq_list = []
grade_column = [['등급', '사례수', {'role': 'style'}]]
if str(MajorGroup.objects.get(pk=major_group_query)) == '자연':
grade_freq_qs = Student.objects \
.filter(entrance_year=entrance_year_query) \
.filter(major_group=major_group_query) \
.filter(univ_region=univ_region_query) \
.values_list(Floor('ko_en_math_sci_100')) \
.annotate(student_grade_count=Count(Floor('ko_en_math_sci_100')))
elif str(MajorGroup.objects.get(pk=major_group_query)) == '공통':
grade_freq_qs = Student.objects \
.filter(entrance_year=entrance_year_query) \
.filter(major_group=major_group_query) \
.filter(univ_region=univ_region_query) \
.values_list(Floor('ko_en_math_soc_sci_100')) \
.annotate(student_grade_count=Count(Floor('ko_en_math_soc_sci_100')))
else:
grade_freq_qs = Student.objects \
.filter(entrance_year=entrance_year_query) \
.filter(major_group=major_group_query) \
.filter(univ_region=univ_region_query) \
.values_list(Floor('ko_en_math_soc_100')) \
.annotate(student_grade_count=Count(Floor('ko_en_math_soc_100')))
for grade in grade_freq_qs:
grade_list.append(int(grade[0]))
grade_freq_list.append(grade[1])
for i in range(0, len(grade_list)):
grade_column.append([
grade_list[i],
grade_freq_list[i],
'color: #3162C7; stroke-color: #000000; stroke-width: 2; opacity: 0.8',
])
#계열, 지역기준 등급분포(table chart)1
grade_column_table = []
sum_list = ['합', 0, 0, 0]
for i in range(1, 9):
grade_column_table.append([str(i), 0, 0, 0])
if str(MajorGroup.objects.get(pk=major_group_query)) == '자연':
grade_freq_qs = Student.objects \
.filter(entrance_year=entrance_year_query) \
.filter(major_group=major_group_query) \
.values_list(Floor('ko_en_math_sci_100')) \
.annotate(student_grade_count=Count(Floor('ko_en_math_sci_100')))
elif str(MajorGroup.objects.get(pk=major_group_query)) == '공통':
grade_freq_qs = Student.objects \
.filter(entrance_year=entrance_year_query) \
.filter(major_group=major_group_query) \
.values_list(Floor('ko_en_math_soc_sci_100')) \
.annotate(student_grade_count=Count(Floor('ko_en_math_soc_sci_100')))
else:
grade_freq_qs = Student.objects \
.filter(entrance_year=entrance_year_query) \
.filter(major_group=major_group_query) \
.values_list(Floor('ko_en_math_soc_100')) \
.annotate(student_grade_count=Count(Floor('ko_en_math_soc_100')))
for data in grade_freq_qs:
grade_column_table[int(data[0] - 1)][1] = data[1]
if str(MajorGroup.objects.get(pk=major_group_query)) == '자연':
grade_freq_qs = Student.objects \
.filter(entrance_year=entrance_year_query) \
.filter(major_group=major_group_query) \
.filter(univ_region=univ_region_query) \
.values_list(Floor('ko_en_math_sci_100')) \
.annotate(student_grade_count=Count(Floor('ko_en_math_sci_100')))
elif str(MajorGroup.objects.get(pk=major_group_query)) == '공통':
grade_freq_qs = Student.objects \
.filter(entrance_year=entrance_year_query) \
.filter(major_group=major_group_query) \
.filter(univ_region=univ_region_query) \
.values_list(Floor('ko_en_math_soc_sci_100')) \
.annotate(student_grade_count=Count(Floor('ko_en_math_soc_sci_100')))
else:
grade_freq_qs = Student.objects \
.filter(entrance_year=entrance_year_query) \
.filter(major_group=major_group_query) \
.filter(univ_region=univ_region_query) \
.values_list(Floor('ko_en_math_soc_100')) \
.annotate(student_grade_count=Count(Floor('ko_en_math_soc_100')))
for data in grade_freq_qs:
grade_column_table[int(data[0] - 1)][2] = data[1]
for row in grade_column_table[1:]:
for i in range(1, 4):
sum_list[i] += row[i]
grade_column_table.append(sum_list)
for i in range(0, 9):
if grade_column_table[i][1] != 0:
grade_column_table[i][3] = round(
(grade_column_table[i][2] / grade_column_table[i][1]) * 100, 1)
#계열, 대학지역 기준 지원대학 현황(bar chart) - 지원대학 사례 순위
univ_name_list = []
univ_freq_list = []
univ_name_qs = UnivName.objects.all()
if admission1_query == '교과':
univ_freq_qs = Student.objects \
.filter(entrance_year=entrance_year_query) \
.filter(major_group=major_group_query) \
.filter(univ_region=univ_region_query) \
.filter(admission1__admission1__contains=admission1_query) \
.values_list('univ_name') \
.annotate(univ_count=Count('univ_name')) \
.order_by('-univ_count')[:25]
elif admission1_query == '종합':
univ_freq_qs = Student.objects \
.filter(entrance_year=entrance_year_query) \
.filter(major_group=major_group_query) \
.filter(univ_region=univ_region_query) \
.filter(admission1__admission1__contains=admission1_query) \
.values_list('univ_name') \
.annotate(univ_count=Count('univ_name')) \
.order_by('-univ_count')[:25]
elif admission1_query == '논술':
univ_freq_qs = Student.objects \
.filter(entrance_year=entrance_year_query) \
.filter(major_group=major_group_query) \
.filter(univ_region=univ_region_query) \
.filter(admission1__admission1__contains=admission1_query) \
.values_list('univ_name') \
.annotate(univ_count=Count('univ_name')) \
.order_by('-univ_count')[:25]
else:
univ_freq_qs = Student.objects \
.filter(entrance_year=entrance_year_query) \
.filter(major_group=major_group_query) \
.filter(univ_region=univ_region_query) \
.filter(admission1__admission1__contains=admission1_query) \
.values_list('univ_name') \
.annotate(univ_count=Count('univ_name')) \
.order_by('-univ_count')[:25]
for univ in univ_freq_qs:
univ_name = univ_name_qs.get(pk=univ[0])
univ_name_list.append(univ_name.univ_name)
univ_freq_list.append(univ[1])
#계열, 전형, 등급기준 지원대학 현황(bar chart) - 지원 대학 합격/충원합격/불합격 현황
univ_pass_freq_list = []
univ_supplement_freq_list = []
univ_fail_freq_list = []
univ_psf_bar = [[
'대학명', '합격', {
'role': 'style'
}, '충원합격', {
'role': 'style'
}, '불합격', {
'role': 'style'
}
]]
for univ in univ_name_list:
univ_name = univ_name_qs.get(univ_name=univ)
univ_pass_freq_count = Student.objects \
.filter(entrance_year=entrance_year_query) \
.filter(major_group=major_group_query) \
.filter(univ_region=univ_region_query) \
.filter(admission1__admission1__contains=admission1_query) \
.filter(univ_name=univ_name.id) \
.filter(final_step='합격') \
.count()
univ_supplement_freq_count = Student.objects \
.filter(entrance_year=entrance_year_query) \
.filter(major_group=major_group_query) \
.filter(univ_region=univ_region_query) \
.filter(admission1__admission1__contains=admission1_query) \
.filter(univ_name=univ_name.id) \
.filter(final_step='충원합격') \
.count()
univ_fail_freq_count = Student.objects \
.filter(entrance_year=entrance_year_query) \
.filter(major_group=major_group_query) \
.filter(univ_region=univ_region_query) \
.filter(admission1__admission1__contains=admission1_query) \
.filter(univ_name=univ_name.id) \
.filter(final_step='불합격') \
.count()
univ_pass_freq_list.append(univ_pass_freq_count)
univ_supplement_freq_list.append(univ_supplement_freq_count)
univ_fail_freq_list.append(univ_fail_freq_count)
univ_pass_freq_list = univ_pass_freq_list[:25]
univ_supplement_freq_list = univ_supplement_freq_list[:25]
univ_fail_freq_list = univ_fail_freq_list[:25]
for i in range(0, len(univ_name_list)):
univ_psf_bar.append([
univ_name_list[i],
univ_pass_freq_list[i],
'stroke-color: #000000; stroke-width: 1; opacity: 0.5',
univ_supplement_freq_list[i],
'stroke-color: #000000; stroke-width: 1; opacity: 0.5',
univ_fail_freq_list[i],
'stroke-color: #000000; stroke-width: 1; opacity: 0.5',
])
context = {
'entrance_year_item':
entrance_year_qs,
'major_group_item':
major_group_qs,
'univ_region_item':
univ_region_qs,
'current_entrance_year':
int(entrance_year_query),
'current_major_group':
int(major_group_query),
'current_major_group_str':
str(MajorGroup.objects.get(pk=major_group_query)),
'current_univ_region':
int(univ_region_query),
'current_univ_region_str':
str(UnivRegion.objects.get(pk=univ_region_query)),
'current_admission1':
admission1_query,
'grade_column':
grade_column,
'grade_column_table':
grade_column_table,
'univ_psf_bar':
univ_psf_bar,
}
return render(request, template, context)
def major_group_result(request):
template = "statistic/major_group_result.html"
entrance_year_qs = Student.objects.values('entrance_year').order_by(
'entrance_year').distinct()
major_group_qs = MajorGroup.objects.order_by('major_group').distinct()
univ_region_qs = UnivRegion.objects.order_by('univ_region').distinct()
admission1_qs = Admission1.objects.values('admission1').order_by(
'admission1').distinct()
entrance_year_query = request.GET.get('entrance_year')
major_group_query = request.GET.get('major_group')
#계열기준 등급분포(column chart)
grade_list = []
grade_freq_list = []
grade_column1 = [['등급', '사례수', {'role': 'style'}]]
if str(MajorGroup.objects.get(pk=major_group_query)) == '자연':
grade_freq_qs = Student.objects \
.filter(entrance_year=entrance_year_query) \
.filter(major_group=major_group_query) \
.values_list(Floor('ko_en_math_sci_100')) \
.annotate(student_grade_count=Count(Floor('ko_en_math_sci_100')))
elif str(MajorGroup.objects.get(pk=major_group_query)) == '공통':
grade_freq_qs = Student.objects \
.filter(entrance_year=entrance_year_query) \
.filter(major_group=major_group_query) \
.values_list(Floor('ko_en_math_soc_sci_100')) \
.annotate(student_grade_count=Count(Floor('ko_en_math_soc_sci_100')))
else:
grade_freq_qs = Student.objects \
.filter(entrance_year=entrance_year_query) \
.filter(major_group=major_group_query) \
.values_list(Floor('ko_en_math_soc_100')) \
.annotate(student_grade_count=Count(Floor('ko_en_math_soc_100')))
for grade in grade_freq_qs:
grade_list.append(int(grade[0]))
grade_freq_list.append(grade[1])
for i in range(0, len(grade_list)):
grade_column1.append([
grade_list[i],
grade_freq_list[i],
'stroke-color: #000000; stroke-width: 2; opacity: 0.8',
])
#계열기준 등급분포(table chart)
grade_column1_list = []
grade_column1_table = []
for idx, admission1 in enumerate(admission1_qs):
if str(MajorGroup.objects.get(pk=major_group_query)) == '자연':
grade_freq_qs = Student.objects \
.filter(entrance_year=entrance_year_query) \
.filter(major_group=major_group_query) \
.filter(admission1__admission1__contains=admission1['admission1']) \
.values_list(Floor('ko_en_math_sci_100')) \
.annotate(student_grade_count=Count(Floor('ko_en_math_sci_100')))
elif str(MajorGroup.objects.get(pk=major_group_query)) == '공통':
grade_freq_qs = Student.objects \
.filter(entrance_year=entrance_year_query) \
.filter(major_group=major_group_query) \
.filter(admission1__admission1__contains=admission1['admission1']) \
.values_list(Floor('ko_en_math_soc_sci_100')) \
.annotate(student_grade_count=Count(Floor('ko_en_math_soc_sci_100')))
else:
grade_freq_qs = Student.objects \
.filter(entrance_year=entrance_year_query) \
.filter(major_group=major_group_query) \
.filter(admission1__admission1__contains=admission1['admission1']) \
.values_list(Floor('ko_en_math_soc_100')) \
.annotate(student_grade_count=Count(Floor('ko_en_math_soc_100')))
grade_column1_list = []
for i in range(1, 9):
grade_column1_list.append(0)
for data in grade_freq_qs:
grade_column1_list[int(data[0] - 1)] = data[1]
grade_column1_list.append(sum(grade_column1_list))
grade_column1_list.insert(0, admission1['admission1'])
grade_column1_table.append(grade_column1_list)
grade_column1_table.sort(key=lambda x: x[9], reverse=True)
# 계열기준 지역별 지원율(pie chart)
univ_region_list = []
univ_region_freq_list = []
for univ_region in univ_region_qs:
univ_region = univ_region.univ_region
univ_region_freq = Student.objects \
.filter(entrance_year=entrance_year_query) \
.filter(major_group=major_group_query) \
.filter(univ_region__univ_region__contains=univ_region) \
.count()
univ_region_list.append(univ_region)
univ_region_freq_list.append(univ_region_freq)
univ_region_pie = []
for i in range(0, len(univ_region_list)):
univ_region_pie.append([univ_region_list[i], univ_region_freq_list[i]])
univ_region_pie.sort(key=lambda x: x[1], reverse=True)
# 계열기준 지역별 지원율(table chart)
univ_region_table = []
total = sum(univ_region_freq_list)
total_ratio = 0
for i in range(0, len(univ_region_list)):
if total != 0:
ratio = round((univ_region_freq_list[i] / total) * 100, 1)
else:
ratio = 0
univ_region_table.append([
univ_region_list[i],
univ_region_freq_list[i],
ratio,
])
total_ratio = 100
univ_region_table.sort(key=lambda x: x[1], reverse=True)
univ_region_table.append(['계', total, total_ratio])
#계열기준 전형비율(pie chart)
admission1_list = []
admission1_freq_list = []
for admission1 in admission1_qs:
admission1 = list(admission1.values())[0]
admission1_freq = Student.objects \
.filter(entrance_year=entrance_year_query) \
.filter(major_group=major_group_query) \
.filter(admission1__admission1__contains=admission1) \
.count()
admission1_list.append(admission1)
admission1_freq_list.append(admission1_freq)
admission1_pie = []
for i in range(0, len(admission1_list)):
admission1_pie.append([admission1_list[i], admission1_freq_list[i]])
admission1_pie.sort(key=lambda x: x[1], reverse=True)
#계열기준 전형비율(table chart)
admission1_table = []
total_ratio = 0
total = sum(univ_region_freq_list)
for i in range(0, len(admission1_list)):
if total != 0:
ratio = round((admission1_freq_list[i] / total) * 100, 1)
else:
ratio = 0
admission1_table.append([
admission1_list[i],
admission1_freq_list[i],
ratio,
])
total_ratio = 100
admission1_table.sort(key=lambda x: x[1], reverse=True)
admission1_table.append(['계', total, total_ratio])
#계열기준 전형별 합격률(column chart)
admission1_pass_freq_list = []
admission1_supplement_freq_list = []
admission1_fail_freq_list = []
admission1_column = []
for admission1 in admission1_qs:
admission1 = list(admission1.values())[0]
admission1_pass_freq_count = Student.objects \
.filter(entrance_year=entrance_year_query) \
.filter(major_group=major_group_query) \
.filter(admission1__admission1__contains=admission1) \
.filter(final_step='합격')\
.count()
admission1_pass_freq_list.append(admission1_pass_freq_count)
admission1_supplement_freq_count = Student.objects \
.filter(entrance_year=entrance_year_query) \
.filter(major_group=major_group_query) \
.filter(admission1__admission1__contains=admission1) \
.filter(final_step='충원합격')\
.count()
admission1_supplement_freq_list.append(
admission1_supplement_freq_count)
admission1_fail_freq_count = Student.objects \
.filter(entrance_year=entrance_year_query) \
.filter(major_group=major_group_query) \
.filter(admission1__admission1__contains=admission1) \
.filter(final_step='불합격')\
.count()
admission1_fail_freq_list.append(admission1_fail_freq_count)
for i in range(0, len(admission1_list)):
admission1_column.append([
admission1_list[i],
admission1_pass_freq_list[i],
'stroke-color: #000000; stroke-width: 1; opacity: 0.5',
admission1_supplement_freq_list[i],
'stroke-color: #000000; stroke-width: 1; opacity: 0.5',
admission1_fail_freq_list[i],
'stroke-color: #000000; stroke-width: 1; opacity: 0.5',
])
admission1_column.sort(key=lambda x: (x[3], x[1]), reverse=True)
admission1_column.insert(0, [
'전형', '합격', {
'role': 'style'
}, '충원합격', {
'role': 'style'
}, '불합격', {
'role': 'style'
}
])
#계열기준 전형별 합격률(table chart)
admission1_table2 = []
total_p = 0
total_s = 0
total_f = 0
total_ratio = 0
for i in range(0, len(admission1_list)):
p = admission1_pass_freq_list[i]
s = admission1_supplement_freq_list[i]
f = admission1_fail_freq_list[i]
if p + s + f == 0:
ratio = 0
else:
ratio = round((p + s) / (p + s + f) * 100, 1)
total_p += p
total_s += s
total_f += f
admission1_table2.append([
admission1_list[i],
admission1_pass_freq_list[i],
admission1_supplement_freq_list[i],
admission1_fail_freq_list[i],
ratio,
])
if total_p + total_s + total_f == 0:
total_ratio = 0
else:
total_ratio = round(
(total_p + total_s) / (total_p + total_s + total_f) * 100, 1)
admission1_table2.sort(key=lambda x: (x[3], x[1]), reverse=True)
admission1_table2.append(['계', total_p, total_s, total_f, total_ratio])
context = {
'entrance_year_item':
entrance_year_qs,
'major_group_item':
major_group_qs,
'current_entrance_year':
int(entrance_year_query),
'current_major_group':
int(major_group_query),
'current_major_group_str':
str(MajorGroup.objects.get(pk=major_group_query)),
'grade_column1':
grade_column1,
'grade_column1_table':
grade_column1_table,
'univ_region_pie':
univ_region_pie,
'univ_region_table':
univ_region_table,
'admission1_pie':
admission1_pie,
'admission1_table':
admission1_table,
'admission1_column':
admission1_column,
'admission1_table2':
admission1_table2,
}
return render(request, template, context)
def test_null(self):
IntegerModel.objects.create()
obj = IntegerModel.objects.annotate(null_floor=Floor('normal')).first()
self.assertIsNone(obj.null_floor)
def get_rental_detail(terminal, str_start_date, str_stop_date):
import math
from datetime import datetime, timedelta
start_date = None
stop_date = None
container_list = {}
if terminal and str_start_date and str_stop_date:
start_date = datetime.strptime(str_start_date, "%Y-%m-%d").date()
stop_date = datetime.strptime(str_stop_date,
"%Y-%m-%d").date() + timedelta(days=1)
rentals = Rental.objects.filter(
terminal=terminal, rent_date__range=[start_date, stop_date])
metrics = {
'total_containers':
Count('container', output_field=FloatField()),
'total_equipments':
Count('che', distinct=True, output_field=FloatField()),
'total_handling_time':
Max('che__kind__handling_time') * F('total_containers'),
'transportation_time':
Max('che__kind__trans_time') * F('total_equipments'),
'total_minutes':
F('total_handling_time') + F('transportation_time'),
'mod_minute':
Floor(F('total_minutes') / 60),
'total_hours':
Floor(F('total_minutes') / 60)
}
reports = rentals.values('rent_date__date',
'che__kind').annotate(**metrics).order_by(
'rent_date__date', 'che__kind')
# reports = rentals.values('rent_date__date','che__kind').annotate(
# total_containers = Count('container'),
# total_handling_time = Sum('che__kind__handling_time'),
# transportation_time = Max('che__kind__trans_time'),
# total_minutes =F('total_handling_time')+F('transportation_time'),
# mod_minute = Floor(F('total_minutes')/60),
# total_hours = Floor(F('total_minutes')/60)).order_by('rent_date__date','che__kind')
for r in reports:
mod_minute = r['total_minutes'] % 60
hours = math.floor(r['total_minutes'] / 60)
hours = hours + (0.5 if mod_minute > 0 and mod_minute < 30 else 0)
hours = hours + (1 if mod_minute >= 30 else 0)
r['mod_minute'] = mod_minute
r['total_hours'] = hours
# print(r['total_minutes'], hours,mod_minute)
container_list = list(reports)
return container_list
# reports = rentals.values('rent_date__date','che__kind').annotate(
# total_containers = Count('container'),
# total_handling_time = Sum('che__kind__handling_time'),
# transportation_time = Max('che__kind__trans_time'),
# total_time =F('total_handling_time')+F('transportation_time'),
# mod_minute = Mod(F('total_time'),60),
# total_hours = Floor(F('total_time')/60) +
# Case(When(mod_minute__gt = 30 , then=Value(1)),
# When(mod_minute__range = [1,29] , then=Value(0.5)),
# default = Value(0),
# output_field = FloatField())
# ).order_by('rent_date__date','che__kind')
# reports = rentals.values('rent_date__date','che__kind').annotate(
# total_containers = Count('container'),
# total_handling_time = Sum('che__kind__handling_time'),
# transportation_time = Max('che__kind__trans_time'),
# total_time = ExpressionWrapper(F('total_handling_time')+F('transportation_time'),output_field=IntegerField()),
# mod_minute = ExpressionWrapper(Mod(62,60),output_field=IntegerField()),
# total_hours = F('total_handling_time')/60).order_by(
# 'rent_date__date','che__kind')
def make_attempts_zero(modeladmin, request, queryset):
# pylint: disable=unused-argument
kwargs = {
field: Floor(F(field) / 10, output_field=IntegerField()) * 10
}
queryset.update(**kwargs)
