def by_class(request, export=False, *args, **kwargs):
o, title = _query(request)
total = {'use_time_total': 0, 'use_count_total': 0}
if o.exists():
total['use_time_total'] = o.aggregate(total=Sum('use_time'))['total']
total['use_count_total'] = o.aggregate(total=Sum('use_count'))['total']
ret = o.values('town_name', 'school_name', 'grade_name',
'class_name').annotate(use_time_total=Sum('use_time'),
use_count_total=Sum('use_count'),
use_days=Count('uuid'))
for i in ret:
i['use_time_average'] = '{0:.2f}'.format(i['use_time_total'] *
1.0 / i['use_days'])
i['use_count_average'] = '{0:.2f}'.format(i['use_count_total'] *
1.0 / i['use_days'])
#ret = []
#towns = list(set(o.values_list('town_name', flat=True)))
#schools = list(set(o.values_list('school_name', flat=True)))
#grades = list(set(o.values_list('grade_name', flat=True)))
#classes = list(set(o.values_list('class_name', flat=True)))
#
# for town in towns:
# for school in schools:
# for grade in grades:
# for cls in classes:
# q = o.filter(town_name=town,
# school_name=school,
# grade_name=grade,
# class_name=cls)
# if not q.exists():
# continue
# ret.append({
# 'town_name': town,
# 'school_name': school,
# 'grade_name': grade,
# 'class_name': cls,
#
# 'use_time_average': '{0:.2f}'.format(q.aggregate(avg=Avg('use_time'))['avg']),
# 'use_time_total': q.aggregate(total=Sum('use_time'))['total'],
# 'use_count_average': '{0:.2f}'.format(q.aggregate(avg=Avg('use_count'))['avg']),
# 'use_count_total': q.aggregate(total=Sum('use_count'))['total'],
# })
if export:
return ret, total, title
return paginatoooor(request, ret, total=total)
if export:
return None, total, title
# return create_failure_dict(msg='该时间段内无机器使用记录')
return paginatoooor(request, [], total=total)
def by_school(request, export=False, *args, **kwargs):
o, title = _query(request)
total = {'use_time_total': 0, 'use_count_total': 0}
if o.exists():
total['use_time_total'] = o.aggregate(total=Sum('use_time'))['total']
total['use_count_total'] = o.aggregate(total=Sum('use_count'))['total']
ret = o.values('town_name', 'school_name').annotate(
use_time_total=Sum('use_time'),
use_count_total=Sum('use_count'),
use_days=Count('uuid'))
for i in ret:
i['use_time_average'] = '{0:.2f}'.format(i['use_time_total'] *
1.0 / i['use_days'])
i['use_count_average'] = '{0:.2f}'.format(i['use_count_total'] *
1.0 / i['use_days'])
i['class_count'] = o.filter(town_name=i['town_name'],
school_name=i['school_name']).values(
'grade_name',
'class_name').distinct().count()
#ret = []
#towns = list(set(o.values_list('town_name', flat=True)))
#schools = list(set(o.values_list('school_name', flat=True)))
# for town in towns:
# for school in schools:
# q = o.filter(town_name=town,
# school_name=school)
# if not q.exists():
# continue
# # 年级-班级
# class_names = set(map(lambda i: '%s%s' % (i[0], i[1]), #去重
# q.values_list('grade_name', 'class_name', flat=False)))
# ret.append({
# 'town_name': town,
# 'school_name': school,
#
# 'class_count': len(class_names),
# 'use_time_average': '{0:.2f}'.format(q.aggregate(avg=Avg('use_time'))['avg']),
# 'use_time_total': q.aggregate(total=Sum('use_time'))['total'],
# 'use_count_average': '{0:.2f}'.format(q.aggregate(avg=Avg('use_count'))['avg']),
# 'use_count_total': q.aggregate(total=Sum('use_count'))['total'],
# })
if export:
return ret, total, title
return paginatoooor(request, ret, total=total)
if export:
return None, total, title
# return create_failure_dict(msg='该时间段内无机器使用记录')
return paginatoooor(request, [], total=total)
def list_current(request, *args, **kwargs):
"""年级班级管理>班班通电脑教室>显示电脑教室"""
terms = models.Term.objects.filter(deleted=False)
q = models.Class.objects.filter(grade__term__in=terms, grade__number=13)
uuids = q.values_list('uuid', flat=True)
cc = models.ComputerClass.objects.filter(
class_bind_to__in=uuids).order_by('class_bind_to__number')
ret = []
for i in cc:
d = {}
d['uuid'] = i.class_bind_to.uuid
d['computerclass_uuid'] = i.uuid
d['mac'] = i.class_bind_to.mac()
d['school_year'] = i.class_bind_to.grade.term.school_year
d['term_type'] = i.class_bind_to.grade.term.term_type
d['name'] = i.class_bind_to.name
d['number'] = i.class_bind_to.number
d['client_number'] = i.client_number
d['lesson_range'] = [
list(j)
for j in i.lesson_range.values_list('uuid', 'name', flat=False)
]
d['grade_name'] = i.class_bind_to.grade.name
ret.append(d)
return paginatoooor(request, ret)
def terminal_boot_by_town(request, export=False, *args, **kwargs):
"""教学点终端开机统计>按乡镇街道"""
o, m, title, days = _query(request)
total = {
'boot_time_total': _aggregate(o, m)['boot_time'],
'boot_count_total': _aggregate(o, m)['boot_count']
}
ret = []
if o.exists():
towns = list(set(o.values_list('town_name', flat=True)))
for town in towns:
p = o.filter(town_name=town)
if not p.exists():
continue
d = _aggregate(p, m, True)
ret.append({
'town_name':
town,
'room_count':
d['room_count'],
'boot_time_total':
d['boot_time'],
'boot_count_total':
d['boot_count'],
'boot_time_average':
'%.2f' % (d['boot_time'] * 1.0 / days),
'boot_count_average':
'%.2f' % (d['boot_count'] * 1.0 / days),
})
if export:
return ret, total, title
return paginatoooor(request, ret, total=total, days=days)
def resource_type(request):
q = models.ResourceType.objects.all()
if models.Setting.getvalue('server_type') == 'school':
q = q.values()
else:
q = q.values('uuid', 'value', 'remark').distinct()
return paginatoooor(request, q)
def computerclass_realtime(request, *args, **kwargs):
"""实时概况>电脑教室桌面预览"""
node = request.GET.get('uuid', None)
if not node:
return create_failure_dict(msg='未获取到获取节点信息')
only_computerclass = True
is_ok, records = _get_globalpreviews(node, only_computerclass)
if is_ok:
return paginatoooor(request, records)
return create_failure_dict(msg=records)
def terminal_time_used_log(request, export=False, *args, **kwargs):
try:
grade_name = request.GET.get('grade_name', None)
class_name = request.GET.get('class_name', None)
o, title = _query(request)
total = {'use_time_total': 0, 'use_count_total': 0}
if o.exists():
if grade_name:
o = o.filter(grade_name=grade_name)
if class_name:
o = o.filter(class_name=class_name)
total['use_time_total'] = o.aggregate(
total=Sum('use_time'))['total']
total['use_count_total'] = o.aggregate(
total=Sum('use_count'))['total']
ret = []
for i in o:
ret.append({
'town_name': i.town_name,
'school_name': i.school_name,
'grade_name': i.grade_name,
'class_name': i.class_name,
'mac': i.mac,
'create_time': str(i.create_time)[:10],
'use_time': i.use_time,
'use_count': i.use_count
})
if export:
return ret, total, title
return paginatoooor(request, ret, total=total)
if export:
return None, total, title
return paginatoooor(request, [], total=total)
except:
if settings.DEBUG:
traceback.print_exc()
return paginatoooor(request, [], total=total)
def realtime(request, *args, **kwargs):
"""实时概况>班班通桌面预览"""
node = request.GET.get('uuid', None)
if not node:
return create_failure_dict(msg='未获取到获取节点信息')
only_computerclass = False
is_ok, records = _get_globalpreviews(node, only_computerclass)
if is_ok:
return paginatoooor(request, records)
return create_failure_dict(msg=records,
data={'page_count': 1, 'page': 1,
'page_size': 4, 'record_count': 0,
'records': []})
def terminal_use(request, *args, **kwargs):
"""教师授课>教学点终端使用日志"""
o, total = _query(request)
ret = []
if o.exists():
ret = map(lambda i: {
'town_name': i.town_name,
'point_name': i.point_name,
'number': i.number,
'use_time': i.use_time,
'boot_time': i.boot_time,
'date': i.create_time,
'to_class_time': '{0:.2f}'.format(i.use_time / 45.0),
}, o)
return paginatoooor(request, ret, total=total)
def terminal_boot(request, *args, **kwargs):
"""教师授课>教学点终端开机日志"""
ret = []
o, total = _query2(request)
if o.exists():
for i in o:
ret.append({'town_name': i.town_name,
'point_name': i.point_name,
'number': i.number,
'create_time': datetime.datetime.strftime(i.create_time, '%Y-%m-%d'),
#'use_time': i.use_time,
'boot_time': i.boot_time,
#'use_count': i.use_count
'boot_count': i.boot_count
})
return paginatoooor(request, ret, total=total)
def classroom_use_by_town(request, export=False, *args, **kwargs):
"""教学点教室使用统计>按乡镇街道"""
edu_objs, timeused_objs, title, days = _query(request)
total = _aggregate(edu_objs, timeused_objs)
ret = []
if edu_objs.exists():
towns = list(set(edu_objs.values_list('town_name', flat=True)))
for town in towns:
p = edu_objs.filter(town_name=town)
if not p.exists():
continue
d = _aggregate(p, timeused_objs, True)
d['town_name'] = town
ret.append(d)
if export:
return ret, total, title
return paginatoooor(request, ret, total=total)
def classroom_use_by_unit_class(request, export=False, *args, **kwargs):
"""教学点教室使用统计>按教学点教室"""
edu_objs, timeused_objs, title, days = _query(request)
total = _aggregate(edu_objs, timeused_objs)
ret = []
if edu_objs.exists():
rooms = models.EduPointDetail.objects.none()
for i in edu_objs:
rooms |= i.edupointdetail_set.filter(type='room')
for i in rooms:
d = _aggregate(i, timeused_objs)
d['town_name'] = i.edupoint.town_name
d['point_name'] = i.edupoint.point_name
d['name'] = i.name
ret.append(d)
if export:
return ret, total, title
return paginatoooor(request, ret, total=total)
def terminal_boot_by_unit_class(request, export=False, *args, **kwargs):
"""教学点终端开机统计>按教学点教室"""
o, m, title, days = _query(request)
total = {
'boot_time_total': _aggregate(o, m)['boot_time'],
'boot_count_total': _aggregate(o, m)['boot_count']
}
ret = []
if o.exists():
towns = list(set(o.values_list('town_name', flat=True)))
for town in towns:
p = o.filter(town_name=town)
if not p.exists():
continue
points = list(set(p.values_list('point_name', flat=True)))
for point in points:
q = p.filter(point_name=point)
if not q.exists():
continue
# d = _aggregate(q, m)
lst = map(
lambda i: {
'town_name':
town,
'point_name':
point,
'number':
i.number,
'boot_time_total':
_aggregate(i, m)['boot_time'],
'boot_count_total':
_aggregate(i, m)['boot_count'],
'boot_time_average':
'%.2f' % (_aggregate(i, m)['boot_time'] * 1.0 / days),
'boot_count_average':
'%.2f' % (_aggregate(i, m)['boot_count'] * 1.0 / days),
}, q)
ret.extend(lst)
if export:
return ret, total, title
return paginatoooor(request, ret, total=total)
def leest(request, *args, **kwargs):
"""系统设置>服务器管理>教学点教室终端管理>列表显示"""
server_type = Setting.getvalue('server_type')
if server_type != 'country':
return create_failure_dict(msg='错误的服务器级别')
o = list(_query(request))
ret = map(
lambda i: {
'uuid': i['pk'],
'school_year': i['edupoint__school_year'],
'term_type': i['edupoint__term_type'],
'town_name': i['edupoint__town_name'],
'point_name': i['edupoint__point_name'],
'key': i['communicate_key'],
'status': i['cpuID'] and i['cpuID'] and '已申报' or '未申报',
'number': i['name'],
'last_active_time': i['last_active_time'],
'last_upload_time': i['last_upload_time'],
}, o)
return paginatoooor(request, ret)
def list_current(request, *args, **kwargs):
if request.method == 'GET':
q = models.Role.objects.all()
q = q.values('uuid', 'name', 'remark')
return paginatoooor(request, q)
def get_node_info(request, *args, **kwargs):
"""班班通桌面使用日志，用于返回请求的节点辖区的信息"""
school_year = request.GET.get('school_year', None)
term_type = request.GET.get('term_type', None)
lesson_period_sequence = request.GET.get('lesson_period_sequence', None)
uu = request.GET.get('uuid', None)
server_type = models.Setting.getvalue('server_type')
root_name = models.Setting.getvalue(server_type)
if uu:
try:
node = models.Group.objects.get(uuid=uu)
except:
return create_failure_dict(msg='错误的UUID')
else:
server_type = models.Setting.getvalue('server_type')
node = models.Group.objects.get(group_type=server_type)
if school_year and term_type and node:
if node.group_type in ['city', 'country']:
info = _get_school_class_count(node, school_year, term_type)
elif node.group_type == 'town':
info = _get_class_count(node, school_year, term_type)
elif node.group_type == 'school':
# 学校详细时，先分页，一页6个统计
# q 所有班级(已排序) s开始时间 e结束时间
q, s, e = _get_pic_count(node, school_year, term_type)
# 分页处理
page_info = get_page_info(request)
paginator = Paginator(q, 6) # 一页6个
try:
records = list(
paginator.page(page_info['page_num']).object_list)
except EmptyPage:
# If page is out of range (e.g. 9999), deliver last page of results.
records = list(paginator.page(paginator.num_pages).object_list)
# 每一个班级的详细数据
r = []
for c in records:
class_uuid = c['uuid']
class_name = c['grade__name'] + u'年级' + c['name'] + u'班'
pic = models.DesktopPicInfo.objects.filter(
class_uuid=class_uuid)
pic = pic.filter(created_at__range=(s, e))
if lesson_period_sequence:
pic = pic.filter(
lesson_period_sequence=lesson_period_sequence)
r.append({
'uuid': class_uuid,
'name': class_name,
'group_type': 'class',
'pic_count': pic.count()
})
return create_success_dict(
data={
'page': page_info['page_num'],
'page_count': paginator.num_pages,
'page_size': page_info['page_size'],
'record_count': paginator.count,
'records': r,
})
else:
return create_failure_dict(msg='错误的节点类型')
return paginatoooor(request, info, root_name=root_name)
return create_failure_dict(msg='获取参数失败！')
def screenshot_node_info(request, *args, **kwargs):
"""教师授课>教学点桌面使用日志>节点信息获取"""
f = lambda x: x == 'country' and 'town' or x
server_type = Setting.getvalue('server_type')
root_name = Setting.getvalue(server_type)
if server_type == 'school':
return create_failure_dict(msg=u'错误的服务器级别.')
node_type = request.GET.get('node_type', f(server_type))
o, pic, conditions = _query(request, node_type)
q = models.EduPointDetail.objects.none()
for i in o:
q |= i.edupointdetail_set.filter(type='room')
for i in ('province', 'city', 'country', 'town', 'unit', 'room'):
if node_type == i:
break
name = '%s_name' % (i != 'unit' and i or 'point')
if not conditions[name]:
return create_failure_dict(msg=u'父级参数不完整(%s)' % name)
for i in conditions.keys():
if not conditions[i]:
del conditions[i]
ret = []
if node_type == 'province':
provinces = list(set(o.values_list('province_name', flat=True)))
for province_name in provinces:
oo = o.filter(province_name=province_name)
# qq = q.filter(edupoint__province_name=province_name)
pp = pic.filter(edupoint__province_name=province_name)
ret.append({
'parent_name': province_name,
'node_type': 'province',
'child_type': 'city',
'unit_count': oo.count(),
'room_count': oo.aggregate(n=Sum('number'))['n'],
'pic_count': pp.count(),
})
conditions['parent_key'] = 'province_name'
elif node_type == 'city':
citys = list(set(o.values_list('city_name', flat=True)))
for city_name in citys:
oo = o.filter(city_name=city_name)
# qq = q.filter(edupoint__city_name=city_name)
pp = pic.filter(edupoint__city_name=city_name)
ret.append({
'parent_name': city_name,
'node_type': 'city',
'child_type': 'country',
'unit_count': oo.count(),
'room_count': oo.aggregate(n=Sum('number'))['n'],
'pic_count': pp.count(),
})
conditions['parent_key'] = 'city_name'
elif node_type == 'country':
countrys = list(set(o.values_list('country_name', flat=True)))
for country_name in countrys:
oo = o.filter(country_name=country_name)
# qq = q.filter(edupoint__country_name=country_name)
pp = pic.filter(edupoint__country_name=country_name)
ret.append({
'parent_name': country_name,
'node_type': 'country',
'child_type': 'town',
'unit_count': oo.count(),
'room_count': oo.aggregate(n=Sum('number'))['n'],
'pic_count': pp.count(),
})
conditions['parent_key'] = 'country_name'
elif node_type == 'town':
towns = list(set(o.values_list('town_name', flat=True)))
for town_name in towns:
oo = o.filter(town_name=town_name)
# qq = q.filter(edupoint__town_name=town_name)
pp = pic.filter(edupoint__town_name=town_name)
ret.append({
'parent_name': town_name,
'node_type': 'town',
'child_type': 'unit',
'unit_count': oo.count(),
'room_count': oo.aggregate(n=Sum('number'))['n'],
'pic_count': pp.count(),
})
conditions['parent_key'] = 'town_name'
elif node_type == 'unit':
points = list(set(o.values_list('point_name', flat=True)))
for point_name in points:
oo = o.filter(point_name=point_name)
# qq = q.filter(edupoint__point_name=point_name)
pp = pic.filter(edupoint__point_name=point_name)
ret.append({
'parent_name': point_name,
'node_type': 'unit',
'child_type': 'room',
'unit_count': oo.count(),
'room_count': oo.aggregate(n=Sum('number'))['n'],
'pic_count': pp.count(),
})
conditions['parent_key'] = 'point_name'
elif node_type == 'room':
ret = map(
lambda i: {
'parent_name': i.name,
'node_type': 'room',
'child_type': 'none',
'unit_count': 1,
'room_count': 1,
'point_id': i.edupoint.pk,
'room_id': i.pk,
'pic_count': pic.filter(edupointdetail=i).count(),
}, q)
conditions['parent_key'] = 'room_name'
return paginatoooor(request,
ret,
conditions=conditions,
root_name=root_name)
