def handle(self, *args, **options):
server_type = Setting.getvalue('server_type')
if server_type != 'country':
print 'Wrong server_type'
raise Exception(u'错误的服务器级别')
term = NewTerm.get_current_or_next_term()
if not term:
print 'There is no term available in the database'
raise Exception(u'无可用学年学期')
print 'current term', term.school_year, term.term_type
pre_term = NewTerm.get_previous_term(term=term)
if not pre_term:
print 'There is no pre_term'
raise Exception(u'无可用学年学期')
print 'pre_term', pre_term.school_year, pre_term.term_type
objs1 = models.EduPoint.objects.filter(
school_year=pre_term.school_year, term_type=pre_term.term_type)
for o in objs1:
point, is_new = models.EduPoint.objects.get_or_create(
school_year=term.school_year,
term_type=term.term_type,
province_name=o.province_name,
city_name=o.city_name,
country_name=o.country_name,
town_name=o.town_name,
point_name=o.point_name,
number=o.number,
remark=o.remark,
communicate_key=o.communicate_key)
if is_new:
print 'create one edupoint item:', point.point_name
objs = list(o.edupointdetail_set.all())
if is_new:
print 'child_set count:', objs.count()
for oo in objs:
models.EduPointDetail.objects.create(
edupoint=point,
type=oo.type,
name=oo.name,
communicate_key=oo.communicate_key,
grade_name=oo.grade_name,
class_name=oo.class_name,
cpuID=oo.cpuID,
need_confirm=True)
def query(cond, excludes):
school_year = cond.get('school_year')
term_type = cond.get('term_type')
start_date = cond.get('start_date')
end_date = cond.get('end_date')
country_name = cond.get('country_name')
town_name = cond.get('town_name')
school_name = cond.get('school_name')
grade_name = cond.get('grade_name')
class_name = cond.get('class_name')
lesson_name = cond.get('lesson_name')
#resource_from = cond.get('resource_from')
resource_type = cond.get('resource_type')
teacher_name = cond.get('teacher_name')
q = TeacherLoginLog.objects.exclude(**excludes)
title = ''
if start_date and end_date:
s = parse_date(start_date)
e = parse_date(end_date)
s = datetime.datetime.combine(s, datetime.time.min)
e = datetime.datetime.combine(e, datetime.time.max)
q = q.filter(created_at__range=(s, e))
title = '%s-%s' % (start_date.replace('-',
''), end_date.replace('-', ''))
elif school_year and term_type:
q = q.filter(term_school_year=school_year, term_type=term_type)
term = Term.objects.filter(school_year=school_year,
term_type=term_type)
title = '%s-%s' % (str(start_date).replace(
'-', ''), str(end_date).replace('-', ''))
else:
term = NewTerm.get_nearest_term()
if term:
q = q.filter(term_school_year=term.school_year)
q = q.filter(term_type=term.term_type)
title = '%s-%s' % (str(term.start_date).replace(
'-', ''), str(term.end_date).replace('-', ''))
if country_name:
q = q.filter(country_name=country_name)
if town_name:
q = q.filter(town_name=town_name)
if school_name:
q = q.filter(school_name=school_name)
if grade_name:
q = q.filter(grade_name=grade_name)
if class_name:
q = q.filter(class_name=class_name)
if lesson_name:
q = q.filter(lesson_name=lesson_name)
# if resource_from:
# q = q.filter(resource_from=resource_from)
if resource_type:
q = q.filter(resource_type=resource_type)
if teacher_name:
q = q.filter(teacher_name__contains=teacher_name)
total = q.count()
#q = q.order_by('country_name', 'school_name', 'grade_name', 'class_name', 'teacher_name')
return q, total, title
def _query(request, node_type):
lst = ('province', 'city', 'country', 'town', 'school', 'unit', 'room')
f = lambda x, y: lst.index(x) <= lst.index(y) and Setting.getvalue(
x) or None
d = { # 前端将后台返回的 conditions 解析了,这里重组一下
'province_name': request.GET.get('province_name',
f('province', node_type)),
'city_name': request.GET.get('city_name', f('city', node_type)),
'country_name': request.GET.get('country_name',
f('country', node_type)),
'town_name': request.GET.get('town_name', None),
'point_name': request.GET.get('point_name', None),
'room_name': request.GET.get('room_name', None),
'parent_key': request.GET.get('parent_key', '_init')
}
school_year = request.GET.get('school_year', None)
term_type = request.GET.get('term_type', None)
parent = request.GET.get('parent', None)
d[d['parent_key']] = parent
if d['parent_key'] != '_init' and d.has_key('_init'):
del d['_init']
o = models.EduPoint.objects.all()
pic = models.EduPointDetailDesktopViewLog.objects.all()
if d['province_name'] and lst.index(node_type) > 0:
o = o.filter(province_name=d['province_name'])
pic = pic.filter(province_name=d['province_name'])
if d['city_name'] and lst.index(node_type) > 1:
o = o.filter(city_name=d['city_name'])
pic = pic.filter(city_name=d['city_name'])
if d['country_name'] and lst.index(node_type) > 2:
o = o.filter(country_name=d['country_name'])
pic = pic.filter(country_name=d['country_name'])
if d['town_name'] and lst.index(node_type) > 3:
o = o.filter(town_name=d['town_name'])
pic = pic.filter(town_name=d['town_name'])
if d['point_name'] and lst.index(node_type) > 4:
o = o.filter(point_name=d['point_name'])
pic = pic.filter(point_name=d['point_name'])
if d['room_name'] and lst.index(node_type) > 5:
o = o.filter(number=d['room_name'])
pic = pic.filter(number=d['room_name'])
if school_year or term_type:
if school_year:
o = o.filter(school_year=school_year)
pic = pic.filter(school_year=school_year)
if term_type:
o = o.filter(term_type=term_type)
pic = pic.filter(term_type=term_type)
else:
# if not school_year and not term_type:
t = NewTerm.get_current_term()
if not t:
return create_failure_dict(msg='学年学期获取失败')
o = o.filter(school_year=t.school_year, term_type=t.term_type)
pic = pic.filter(school_year=t.school_year, term_type=t.term_type)
o = o.order_by('province_name', 'city_name', 'town_name', 'point_name')
return o, pic, d
def list(request, *args, **kwargs):
"""
教学点管理>列表显示
"""
school_year = request.GET.get('school_year')
term_type = request.GET.get('term_type')
town_name = request.GET.get('town_name')
point_name = request.GET.get('point_name')
q = EduPoint.objects.all()
if school_year or term_type:
if school_year:
q = q.filter(school_year=school_year)
if term_type:
q = q.filter(term_type=term_type)
else:
term = NewTerm.get_nearest_term()
if term:
q = q.filter(
school_year=term.school_year,
term_type=term.term_type
)
if town_name:
q = q.filter(town_name=town_name)
if point_name:
q = q.filter(point_name=point_name)
page_info = get_page_info(request)
q = q.values('id', 'school_year', 'term_type', 'town_name', 'point_name', 'number', 'remark').distinct()
# 添加一个uuid,与id是一样的
map(lambda x: x.setdefault('uuid', x['id']), q)
paginator = Paginator(q, page_info['page_size'])
records = paginator.page(page_info['page_num']).object_list
ret = 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': model_list_to_dict(records),
})
return ret
def _query(request):
school_year = request.GET.get('school_year', None)
term_type = request.GET.get('term_type', None)
town_name = request.GET.get('town_name', None)
point_name = request.GET.get('point_name', None)
key = request.GET.get('key', None)
status = request.GET.get('status', None)
type = 'receiver' in request.path and 'moon' or 'room'
o = models.EduPointDetail.objects.filter(type=type)
if school_year or term_type:
if school_year:
o = o.filter(edupoint__school_year=school_year)
if term_type:
o = o.filter(edupoint__term_type=term_type)
else:
term = NewTerm.get_current_or_next_term()
if term:
o = o.filter(edupoint__school_year=term.school_year,
edupoint__term_type=term.term_type)
else:
o = models.EduPointDetail.objects.none()
if town_name:
o = o.filter(edupoint__town_name=town_name)
if point_name:
o = o.filter(edupoint__point_name=point_name)
if key:
o = o.filter(communicate_key__contains=key.upper())
if status == u'已申报':
o = o.exclude(cpuID='')
elif status == u'未申报':
o = o.filter(cpuID='')
o = o.order_by('edupoint__town_name', 'edupoint__point_name', 'pk')
o = o.values('edupoint__school_year', 'edupoint__term_type',
'edupoint__town_name', 'communicate_key',
'edupoint__point_name', 'pk', 'cpuID', 'last_active_time',
'last_upload_time', 'name')
return o
def add(request, *args, **kwargs):
'''
教学点管理>添加
'''
def _getvalue(name):
return Setting.getvalue(name)
term = NewTerm.get_current_or_next_term()
if not term:
return create_failure_dict(msg=u'无可用学年学期')
if request.method == 'POST':
if _getvalue('server_type') != 'country':
return create_failure_dict(msg='教学点仅支持县级服务器')
f = EduPointUploadForm(request.POST)
if f.is_valid():
# 新建教学点
cleaned_data = f.cleaned_data
obj, c = EduPoint.objects.get_or_create(
school_year=cleaned_data['school_year'],
term_type=cleaned_data['term_type'],
province_name=_getvalue('province'),
city_name=_getvalue('city'),
country_name=_getvalue('country'),
town_name=cleaned_data['town_name'],
point_name=cleaned_data['point_name'].replace(' ', ''),
defaults={
'number': cleaned_data['number'],
'remark': cleaned_data['remark'],
}
)
if c:
return create_success_dict(msg='成功添加教学点')
else:
return create_failure_dict(msg='不能重复添加教学点')
return create_failure_dict(msg='教学点添加失败', errors=f.errors)
def handle(self, *args, **options):
server_type = Setting.getvalue('server_type')
if server_type != 'school':
current_term = NewTerm.get_current_term()
terms = NewTerm.objects.all()
if current_term:
terms = terms.exclude(pk=current_term.pk)
else:
current_term = Term.get_current_term_list()
terms = Term.objects.all()
if current_term:
uuids = [o.pk for o in current_term]
terms = terms.exclude(pk__in=uuids)
uuids = Setting.objects.filter(name='task-init-statictic-term')
uuids = list(uuids.values_list('value', flat=True))
if uuids:
terms = terms.exclude(pk__in=uuids)
for term in terms:
logger.debug('task-init-statictic-term: %s %s' %
(term.school_year, term.term_type))
Statistic.init_all(term)
Statistic.update_all(term)
def _resource_store_query(cond):
school_year = cond.get('school_year')
term_type = cond.get('term_type')
start_date = cond.get('start_date')
end_date = cond.get('end_date')
town_name = cond.get('town_name')
point_name = cond.get('point_name')
title = u''
q = models.EduPointResourceReceLog.objects.all()
e = models.EduPoint.objects.all()
if school_year or term_type:
if school_year:
q = q.filter(school_year=school_year)
e = e.filter(school_year=school_year)
title = school_year
if term_type:
q = q.filter(term_type=term_type)
e = e.filter(term_type=term_type)
if school_year:
term = Term.objects.filter(school_year=school_year,
term_type=term_type)
if term.exists():
term = term[0]
title = u'%s-%s' % (str(term.start_date).replace(
'-', ''), str(term.end_date).replace('-', ''))
elif start_date and end_date:
start = parse_date(start_date)
end = parse_date(end_date)
start = datetime.datetime.combine(start, datetime.time.min)
end = datetime.datetime.combine(end, datetime.time.max)
q = q.filter(rece_time__range=(start, end))
e = e.filter(create_time__range=(start, end))
title = u'%s-%s' % (start_date.replace('-',
''), end_date.replace('-', ''))
else:
term = NewTerm.get_nearest_term()
if term:
q = q.filter(school_year=term.school_year,
term_type=term.term_type)
e = e.filter(school_year=term.school_year,
term_type=term.term_type)
title = u'%s-%s' % (str(term.start_date).replace(
'-', ''), str(term.end_date).replace('-', ''))
if town_name:
q = q.filter(town_name=town_name)
e = e.filter(town_name=town_name)
if point_name:
q = q.filter(point_name=point_name)
e = e.filter(point_name=point_name)
# 资源接收总大小
total_resource_size = q.aggregate(total=Sum('rece_size'))['total']
if not total_resource_size:
total_resource_size = 0
# 资源接收总个数
total_resource_count = q.aggregate(total=Sum('rece_count'))['total']
if not total_resource_count:
total_resource_count = 0
q = q.order_by('town_name', 'point_name')
return q, total_resource_size, total_resource_count, title, e
def _query(request):
f = Setting.getvalue
province_name = request.REQUEST.get('province_name', f('province'))
city_name = request.REQUEST.get('city_name', f('city'))
country_name = request.REQUEST.get('country_name', f('country'))
town_name = request.REQUEST.get('town_name', None)
point_name = request.REQUEST.get('point_name', None)
start_date = request.REQUEST.get('start_date', None)
end_date = request.REQUEST.get('end_date', None)
school_year = request.REQUEST.get('school_year', None)
term_type = request.REQUEST.get('term_type', None)
title = u'导出'
o = models.EduPoint.objects.all()
m = models.EduPointMachineTimeUsed.objects.all()
o = o.filter(province_name=province_name)
o = o.filter(city_name=city_name)
o = o.filter(country_name=country_name)
m = m.filter(province_name=province_name)
m = m.filter(city_name=city_name)
m = m.filter(country_name=country_name)
if town_name:
o = o.filter(town_name=town_name)
m = m.filter(town_name=town_name)
if point_name:
o = o.filter(point_name=point_name)
m = m.filter(point_name=point_name)
days = 1.0
now = datetime.datetime.today().date()
if school_year or term_type:
if school_year:
o = o.filter(school_year=school_year)
m = m.filter(school_year=school_year)
title = school_year
if term_type:
o = o.filter(term_type=term_type)
m = m.filter(term_type=term_type)
if school_year:
term = NewTerm.objects.filter(school_year=school_year,
term_type=term_type)
if term.exists():
term = term[0]
title = '%s-%s' % (str(term.start_date).replace(
'-', ''), str(term.end_date).replace('-', ''))
days = (now - term.start_date).days
elif start_date and end_date:
start_date = parse_date(start_date)
end_date = parse_date(end_date)
s = datetime.datetime.combine(start_date, datetime.time.min)
e = datetime.datetime.combine(end_date, datetime.time.max)
cond = Q(start_date__lte=s, end_date__gte=s)
cond |= Q(start_date__gte=s, end_date__lte=e)
cond |= Q(start_date__lte=e, end_date__gte=e)
terms = list(NewTerm.objects.filter(cond))
for t in terms:
if terms.index(t) == 0:
cond = Q(school_year=t.school_year, term_type=t.term_type)
else:
cond |= Q(school_year=t.school_year, term_type=t.term_type)
o = o.filter(cond)
m = m.filter(create_time__range=(start_date, end_date))
days = (now - start_date).days
days = days and days or 1.0
else:
term = NewTerm.get_nearest_term()
if term:
o = o.filter(school_year=term.school_year,
term_type=term.term_type)
m = m.filter(school_year=term.school_year,
term_type=term.term_type)
title = '%s-%s' % (str(term.start_date).replace(
'-', ''), str(term.end_date).replace('-', ''))
days = (now - term.start_date).days
o = o.order_by(
'school_year',
'term_type',
'country_name',
'town_name',
'point_name',
'-create_time',
)
return o, m, title, abs(days)
def get_node_trees(request, *args, **kwargs):
"""系统设置>教学点>节点树,用于条件联动"""
__f = lambda name: Setting.getvalue(name)
node_type = request.GET.get('node_type', None)
province_name = request.GET.get('province_name', __f('province'))
city_name = request.GET.get('city_name', __f('city'))
country_name = request.GET.get('country_name', __f('country'))
town_name = request.GET.get('town_name', None)
point_name = request.GET.get('point_name', None)
school_year = request.GET.get('school_year', None)
term_type = request.GET.get('term_type', None)
status = request.GET.get('status', None)
ori = request.GET.get('ori', None) # 数据源: GroupTB or 实际存在的数据
type_index = ('province', 'city', 'country', 'town', 'unit', 'room')
# 下面的用于限定父级参数不完整的时候不返回子级的信息
for i in type_index[3:]:
if node_type == i:
break
name = request.GET.get('%s_name' % (i != 'unit' and i or 'point'),
None)
if not name:
return create_success_dict(data={'records': []})
o = models.EduPoint.objects.all()
if province_name and type_index.index(node_type) > 0:
o = o.filter(province_name=province_name)
if city_name and type_index.index(node_type) > 1:
o = o.filter(city_name=city_name)
if country_name and type_index.index(node_type) > 2:
o = o.filter(country_name=country_name)
if town_name and type_index.index(node_type) > 3:
o = o.filter(town_name=town_name)
if point_name and type_index.index(node_type) > 4:
o = o.filter(point_name=point_name)
if status == u'已申报':
o = o.exclude(edupointdetail__cpuID='')
elif status == u'未申报':
o = o.filter(edupointdetail__cpuID='')
if school_year or term_type:
if school_year:
o = o.filter(school_year=school_year)
if term_type:
o = o.filter(term_type=term_type)
else:
# if not school_year and not term_type: # by default
term = NewTerm.get_current_or_next_term()
if not term:
return create_failure_dict(msg=u'无可用学年学期')
o = o.filter(school_year=term.school_year)
o = o.filter(term_type=term.term_type)
o = o.order_by('province_name', 'city_name', 'country_name', 'town_name',
'point_name', 'create_time')
lst = []
# We have 7 level:
# province, city, country, town, school/unit, grade, class/room
# Part I: province city country town -- form GroupTB
# Part II: school grade class -- from Group Grade and Class
# Part III: unit room -- from EduPoint and EduPointDetail
# node_type will be asigned to server_type if it is null
if not node_type:
server_type = Setting.getvalue('server_type')
if server_type == 'country':
node_type = 'town'
elif server_type == 'school':
node_type = 'school'
else:
return create_failure_dict()
index_lst_1 = ('province', 'city', 'country', 'town')
# Part I
if node_type in index_lst_1:
if ori == 'unit':
lst = list(set(o.values_list('%s_name' % node_type, flat=True)))
else:
g = GroupTB.objects.all()
if index_lst_1.index(node_type) > 0: # city
g = g.get(name=province_name)
if index_lst_1.index(node_type) > 1: # country
g = g.child_set.get(name=city_name)
if index_lst_1.index(node_type) > 2: # town
g = g.child_set.get(name=country_name)
# if index_lst_1.index(node_type) > 3: # school
# g = g.child_set.get(name=town_name)
# if index_lst_1.index(node_type) > 4: # grade
# g = g.child_set.get(name=school_name)
# if index_lst_1.index(node_type) > 5: # class
# g = g.child_set.get(name=grade_name)
if node_type == 'province': # province
lst = g.filter(parent__isnull=True).values_list('name',
flat=True)
else:
lst = g.child_set.values_list('name', flat=True)
# Part II
elif node_type == 'school':
g2 = Group.objects.all().filter(group_type=node_type)
lst = list(set(g2.values_list('name', flat=True)))
# Part III
elif node_type == 'unit':
# if not (school_year and term_type):
# return create_failure_dict(msg='#both school_year and term_type \
# needed in this node_type')
lst = o.values_list('point_name', flat=True)
elif node_type == 'room':
# if not (school_year and term_type and town_name and point_name):
# return create_failure_dict(msg='#school_year and term_type and \
# town_name and point_name are needed in this node_type')
if o.exists():
room = o[0].edupointdetail_set.filter(type='room')
lst = list(set(room.values_list('name', flat=True)))
else:
lst = []
else:
lst = [
'node_type should in province city country \
town school unit and room'
]
return create_success_dict(
data={'records': map(lambda i: {'key': i}, lst)})
def inherit_items(request, *args, **kwargs):
school_year = request.GET.get('school_year')
term_type = request.GET.get('term_type')
pre_school_year = request.GET.get('pre_school_year')
pre_term_type = request.GET.get('pre_term_type')
server_type = Setting.getvalue('server_type')
if server_type != 'country':
# print 'Wrong server_type'
return create_failure_dict(msg=u'错误的服务器级别', debug=server_type)
if school_year and term_type:
try:
term = NewTerm.objects.get(school_year=school_year,
term_type=term_type)
except Exception as e:
return create_failure_dict(msg=u'无可用学年学期', debug=str(e))
else:
term = NewTerm.get_current_or_next_term()
if not term:
print 'There is no term available in the database'
return create_failure_dict(msg=u'当前时间/未来时间不存在可用学年学期')
print 'current term', term.school_year, term.term_type
if school_year and term_type:
try:
pre_term = NewTerm.objects.get(school_year=pre_school_year,
term_type=pre_term_type)
except Exception as e:
return create_failure_dict(msg=u'无可用历史学年学期', debug=str(e))
else:
pre_term = NewTerm.get_previous_term(term=term)
if not pre_term:
print 'There is no pre_term'
return create_failure_dict(msg='无可用历史学年学期')
print 'pre_term', pre_term.school_year, pre_term.term_type
objs1 = models.EduPoint.objects.filter(school_year=pre_term.school_year,
term_type=pre_term.term_type)
for o in objs1:
point, is_new = models.EduPoint.objects.get_or_create(
school_year=term.school_year,
term_type=term.term_type,
province_name=o.province_name,
city_name=o.city_name,
country_name=o.country_name,
town_name=o.town_name,
point_name=o.point_name,
number=o.number,
remark=o.remark)
if is_new:
print 'create one edupoint item:', point.point_name
objs = o.edupointdetail_set.all()
if is_new:
print 'child_set count:', objs.count()
for oo in objs:
models.EduPointDetail.objects.get_or_create(
edupoint=point,
type=oo.type,
name=oo.name,
communicate_key=_generate_key())
return create_success_dict(msg=u'操作成功')