def term(request, *args, **kwargs):
if request.method == 'POST':
if models.Setting.getvalue('installed') == 'True':
failure = '您已经配置过本服务器，无法重新配置！'
return create_failure_dict(msg=failure)
f = TermFormSet(request.POST)
if f.is_valid():
models.Term.objects.all().delete() # 删除旧数据进行全新安装
for i in f.forms:
i.save()
install_step = models.Setting.objects.get(name='install_step')
install_step.value = request.POST['install_step']
install_step.save()
return create_success_dict(msg='安装成功！')
return create_failure_dict(msg='安装失败！', errors=f.errors)
elif request.method == "GET":
if models.Setting.getvalue('installed') == 'True':
return HttpResponseRedirect('/')
q = models.Term.objects.all().values('term_type', 'start_date',
'end_date', 'school_year')
return create_success_dict(data=model_list_to_dict(q))
def check_md5(request):
'''
前端校验课件是否有处理过
# existing : 0(无文件无纪录) , 1(有文件无纪录) , 2(有文件有纪录)
'''
md5 = request.GET.get('md5').strip().upper()
mac = request.GET.get('mac').strip().upper()
term_uuid = request.GET.get('term_uuid', make_term_uuid())
if not courseware_exist(md5):
# print '无重复的md5，可以上传'
return create_success_dict(existing=0,
md5=md5,
mac=mac,
msg='无重复的md5，可以上传')
else:
if not teacherloginlogcourseware_exist(md5, mac, term_uuid):
# print '有md5，但无该老师上课纪录'
return create_success_dict(existing=1,
md5=md5,
mac=mac,
msg='有md5，但无该老师上课纪录')
else:
# print '有md5，同时也有该老师上课纪录'
return create_success_dict(existing=2,
md5=md5,
mac=mac,
msg='有md5，同时也有该老师上课纪录')
def grade_class(request, *args, **kwargs):
if request.method == 'POST':
if models.Setting.getvalue('installed') == 'True':
failure = '您已经配置过本服务器，无法重新配置！'
return create_failure_dict(msg=failure)
f = ClassFormSet(request.POST)
if f.is_valid():
# 删除旧数据进行全新安装
cursor = connection.cursor()
cursor.execute('DELETE FROM `Class`')
cursor.execute('DELETE FROM `Grade`')
for i in f.forms:
i.save()
install_step = models.Setting.objects.get(name='install_step')
install_step.value = request.POST['install_step']
install_step.save()
return create_success_dict(msg='安装成功！')
return create_failure_dict(msg='安装失败！', errors=f.errors)
elif request.method == 'GET':
if models.Setting.getvalue('installed') == 'True':
return HttpResponseRedirect('/')
q = models.Class.objects.all().values('grade__name', 'name')
return create_success_dict(data=model_list_to_dict(q))
def clean_token(request, *args, **kwargs):
"""客户端取消当前的登录操作,清除掉本次登录产生的token"""
client_mac = request.GET.get('mac')
term = models.Term.get_current_term_list()
if not term:
return create_failure_dict(msg=u'无可用学年学期.', debug='no term')
cls = models.ClassMacV2.objects.filter(
mac=client_mac,
class_uuid__grade__term=term[0]
)
if not cls.exists():
return create_failure_dict(msg=u'客户端尚未申报.', debug='not reported')
uuid = str(cls[0].class_uuid.pk).lower().replace('-', '')
models.Token.objects.filter(
token_type='lesson_start',
value=uuid
).all().delete()
return create_success_dict(debug=uuid)
# 前端要求这里只传递MAC地址,所以换成上面的清理方法.
token_key = request.GET.get('token')
if token_key:
tokens = models.Token.objects.filter(token_type='lesson_start', value=token_key)
tokens.all().delete()
return create_success_dict(debug=token_key)
return create_failure_dict(msg=u'参数获取失败.', debug='token')
def lesson_name(request, *args, **kwargs):
if request.method == 'POST':
if models.Setting.getvalue('installed') == 'True':
failure = '您已经配置过本服务器，无法重新配置！'
return create_failure_dict(failure)
f = LessonNameFormSet(request.POST)
if f.is_valid():
models.LessonName.objects.all().delete() # 删除旧数据进行全新安装
school = models.Group.objects.get(group_type='school')
for i in f.forms:
obj = i.save(commit=False)
obj.school = school
obj.save()
install_step = models.Setting.objects.get(name='install_step')
install_step.value = request.POST['install_step']
install_step.save()
return create_success_dict(msg='安装成功！')
return create_failure_dict(msg='安装失败！', errors=f.errors)
elif request.method == 'GET':
if models.Setting.getvalue('installed') == 'True':
return HttpResponseRedirect('/')
q = models.LessonName.objects.all().values('name')
return create_success_dict(data=model_list_to_dict(q))
def get_unreported(request, *args, **kwargs):
"""客户端获取未申报的电脑教室列表"""
if models.Setting.getvalue('server_type') != 'school':
return create_failure_dict()
term = models.Term.get_current_term_list()
if not term:
return create_failure_dict(msg='当前时间不在任何学期内')
t = term[0]
cc = models.ComputerClass.objects.filter(class_bind_to__grade__term=t)
if cc.exists():
uuids = models.ClassMacV2.objects.all().values_list('class_uuid',
flat=True)
cc = cc.exclude(class_bind_to__in=uuids).order_by(
'class_bind_to__name',
'class_bind_to__number').values_list('class_bind_to',
'class_bind_to__name',
'class_bind_to__number',
'class_bind_to__grade__uuid',
flat=False)
data = map(
lambda c: {
'uuid': c[0],
'name': c[1],
'number': c[2],
'grade_uuid': c[3]
}, cc)
return create_success_dict(data=data, term=model_list_to_dict(term))
return create_success_dict(data=[])
def get_choices(request):
"""添加班级的时候获取可选的班号"""
grade_name = request.GET.get('grade_name', None)
grade_number = str_util.grade_name_to_number(grade_name)
custom_grade_name = settings.CONF.server.grade_map.get(
grade_name) or settings.CONF.server.grade_map.get(
str(grade_name)) or grade_name
terms = models.Term.get_current_term_list()
if not terms:
return create_success_dict(data=[], debug='no term')
if not grade_name:
return create_success_dict(data=[], debug='grade_name needed')
try:
g = models.Grade.objects.get(term=terms[0],
name=custom_grade_name,
number=grade_number)
lst = g.class_set.values_list('number', flat=True)
lst = set(range(1, max(lst and lst or [1]) + 2)) - set(lst)
numbers = list(lst)
return create_success_dict(data=[{
'text': i
} for i in numbers],
debug='some one')
except models.Grade.DoesNotExist:
return create_success_dict(data=[
{
'text': 1
},
], debug='first one')
except Exception as e:
return create_success_dict(data=[], debug=str(e))
def check_data(request):
if request.method == 'POST':
if models.Setting.getvalue('server_type') == 'school':
return
key = request.POST.get('key')
try:
node = models.Node.objects.get(communicate_key=key)
if node.last_upload_id > 0:
return create_success_dict(data={'has_records': True})
else:
return create_success_dict(data={'has_records': False})
except:
logger.exception('')
return create_failure_dict()
def list_current(request, *args, **kwargs):
school_uuid = request.GET.get('school_uuid')
donot_pagination = request.GET.get('donot_pagination', False)
q = models.LessonName.objects.filter(deleted=False)
if school_uuid:
q = q.filter(school__uuid=school_uuid)
if models.Setting.getvalue('server_type') == 'school':
q = q.values('uuid', 'name', 'types')
else:
q = q.order_by().values('name').distinct()
order_lst = [
u'',
u'小学',
u'小学,初中',
u'小学,高中',
u'小学,初中,高中',
u'初中',
u'初中,高中',
u'高中',
]
if len(q):
q = list(q)
q.sort(key=lambda d: len(d['name']))
q.sort(key=lambda d: d.has_key('types') and d['types'] in order_lst and
order_lst.index(d['types']) or -1)
if donot_pagination == 'true':
return create_success_dict(
data={
'records': model_list_to_dict(q),
'page': 1,
'page_size': len(q),
'record_count': len(q),
'page_count': 1,
})
page_info = get_page_info(request)
page_data = db_utils.pagination(q, **page_info)
return create_success_dict(
data={
'records': model_list_to_dict(page_data['records']),
'page': page_data['page_num'],
'page_size': page_data['page_size'],
'record_count': page_data['record_count'],
'page_count': page_data['page_count'],
})
def add(request, *args, **kwargs):
if request.method == 'POST':
try:
f = LessonTeacherForm(request.POST)
if f.is_valid():
lesson_teacher = f.save()
simplecache.LessonTeacher.update(
lesson_teacher.class_uuid.uuid)
data = model_to_dict(lesson_teacher)
school_year = lesson_teacher.class_uuid.grade.term.school_year
data['class_uuid__grade__term__school_year'] = school_year
term_type = lesson_teacher.class_uuid.grade.term.term_type
data['class_uuid__grade__term__term_type'] = term_type
grade_name = lesson_teacher.class_uuid.grade.name
data['class_uuid__grade__name'] = grade_name
data['class_uuid__name'] = lesson_teacher.class_uuid.name
data['lesson_name__name'] = lesson_teacher.lesson_name.name
data['teacher__name'] = lesson_teacher.teacher.name
try:
stat_obj = models.Statistic.objects.get(
key=lesson_teacher.class_uuid.pk)
stat_obj.cala('teacher_num', True)
except Exception as e:
logger.exception(e)
return create_success_dict(msg='添加班级课程授课教师记录成功！', data=data)
return create_failure_dict(msg='添加班级课程授课教师记录失败！', errors=f.errors)
except IntegrityError:
msg = '已有相同的年级班级-课程-教师姓名，无法重复添加！'
return create_failure_dict(msg=msg)
except Exception as e:
logger.exception(e)
return create_failure_dict(msg=u'添加班级课程授课教师记录失败！', debug=str(e))
def get(request, *args, **kwargs):
if request.method == 'GET':
try:
host = models.Setting.objects.get(name='host')
host = host.value
except:
host = ''
try:
port = models.Setting.objects.get(name='port')
# port = port.value
# FIXME
# 初始化安装的时候,前端请求默认端口(websocket等)
# 这里直接后台固定为 11111
port = '11111'
except:
port = ''
try:
o = models.Setting.objects.get(name='show_download_btn')
show_download_btn = str(o.value).lower()
except:
show_download_btn = 'true'
try:
o = models.Setting.objects.get(name='html_title')
html_title = o.value
except:
html_title = u'噢易班班通管理分析系统'
return create_success_dict(
data={
'host': host,
'port': port,
'show_download_btn': show_download_btn,
'html_title': html_title
})
def delete(request, *args, **kwargs):
if request.method == 'POST':
if not cache.get('sudo'):
return create_failure_dict(msg='请输入正确的超级管理员admin密码！')
uu = request.POST.get('uuid')
if uu:
try:
l = models.LessonPeriod.objects.get(uuid=uu)
except:
return create_failure_dict(msg='错误的uuid！')
term = l.term
try:
if not term.allow_import_lesson():
return create_failure_dict(msg='该作息时间对应的学年学期已过期,不能删除')
except Exception, e:
logger.exception(e)
return create_failure_dict(msg='该作息时间对应学年学期有误,删除失败')
max_sequence = models.LessonPeriod.objects.filter(term=term)
max_sequence = max_sequence.aggregate(Max('sequence'))
if l.sequence == max_sequence['sequence__max']:
l.delete()
return create_success_dict(msg='删除作息时间成功！')
else:
return create_failure_dict(msg='只能删除最大的一个节次！')
def group_get_children(request):
if request.method == 'GET':
if models.Setting.getvalue('installed') == 'True':
failure = '您已经配置过本服务器，无法重新配置！'
return create_failure_dict(msg=failure)
province_name = request.GET.get('province_name')
city_name = request.GET.get('city_name')
country_name = request.GET.get('country_name')
q = None
if province_name and city_name and country_name:
q = models.GroupTB.objects.filter(parent__name=country_name,
parent__parent__name=city_name)
q = q.filter(parent__parent__parent__name=province_name)
q = q.values('name')
elif province_name and city_name:
q = models.GroupTB.objects.filter(parent__name=city_name)
q = q.filter(parent__parent__name=province_name)
q = q.values('name')
elif province_name:
q = models.GroupTB.objects.filter(parent__name=province_name)
q = q.values('name')
else:
q = models.GroupTB.objects.filter(parent_id__isnull=True)
q = q.values('name')
return create_success_dict(data={'children': model_list_to_dict(q)})
def usb_check(request):
if models.Setting.getvalue('server_type') != 'school':
return create_failure_dict()
if request.method == 'GET':
key = request.GET.get('key')
mac = request.GET.get('mac')
try:
u = models.UsbkeyTeacher.objects.get(usbkey_uuid=key)
except:
return create_failure_dict(msg='无效的USBKey！')
try:
t = models.Teacher.objects.get(uuid=u.teacher_uuid)
except:
return create_failure_dict(msg='找不到对应教师！')
try:
c = models.Class.objects.get(classmacv2__mac=mac)
except:
return create_failure_dict(msg='MAC地址未申报！')
q = models.LessonTeacher.objects.filter(class_uuid=c, teacher=t)
if not q.exists():
return create_failure_dict(msg='教师在本班没有排课！')
data = {
'teacher': {
'key': t.uuid,
'sequence': t.sequence,
'name': t.name,
'password': t.password
}
}
return create_success_dict(data=data)
def get_mac_status(request, *args, **kwargs):
'''从MAC地址查询班级申报状态'''
if models.Setting.getvalue('server_type') != 'school':
return create_failure_dict()
terms = models.Term.get_current_term_list()
if not terms:
return create_failure_dict(msg=u'当前时间不在任何学期内')
mac = request.GET.get('mac', '').strip()
ip = request.META['REMOTE_ADDR']
data = {
'reported': False,
'computerclass': False,
'class_uuid': None,
'grade_uuid': None
}
if not mac:
return create_failure_dict(msg=u'客户端MAC获取失败.')
try:
o = models.ClassMacV2.objects.get(mac=mac,
class_uuid__grade__term__in=terms)
if o.ip != ip:
o.ip = ip
o.save()
data['reported'] = True
data['class_uuid'] = o.class_uuid.uuid
data['grade_uuid'] = o.class_uuid.grade.uuid
data['computerclass'] = (o.class_uuid.grade.number == 13)
except models.ClassMacV2.DoesNotExist:
simplecache.set_class_noreport_heartbeat_ip(ip)
except Exception as e:
logger.exception('')
return create_failure_dict(data=data, msg=u'客户端状态获取失败', debug=str(e))
return create_success_dict(data=data)
def verify(request, *args, **kwargs):
if request.method == 'POST':
f = TermUploadForm(request.POST, request.FILES)
if f.is_valid():
ret = f.verify()
return create_success_dict(data={'records': ret})
return create_failure_dict(msg='校验学年学期失败！', errors=f.errors)
def add(request, *args, **kwargs):
if request.method == 'POST':
f = ClassForm(request.POST)
if f.is_valid():
f.save()
return create_success_dict(msg='添加班级成功！')
return create_failure_dict(msg='添加班级失败！', errors=f.errors)
def step(request, *args, **kwargs):
if request.method == 'POST':
if models.Setting.getvalue('installed') == 'True':
failure = '您已经配置过本服务器，无法重新配置！'
return create_failure_dict(msg=failure)
f = StepForm(request.POST)
if f.is_valid():
f.save()
return create_success_dict(msg='安装成功！')
return create_failure_dict(msg='安装失败！', errors=f.errors)
elif request.method == 'GET':
install_step = models.Setting.getvalue('install_step')
return create_success_dict(install_step=install_step)
def get_pics_count_by_date(request, *args, **kwargs):
"""班班通桌面使用日志，用于返回请求的日期时间轴的每日桌面预览信息"""
# ValidateDateRangeMiddleware 中简单忽略掉了对时间跨学年学期的判断
start_date = request.GET.get('start_date', None)
end_date = request.GET.get('end_date', None)
class_uuid = request.GET.get('class_uuid', None)
lesson_period_sequence = request.GET.get('lesson_period_sequence', None)
if start_date and end_date and class_uuid:
start_date = parse_date(start_date)
end_date = parse_date(end_date)
ret = {}
n = (end_date - start_date).days + 1
for t in range(n):
created_at = start_date + datetime.timedelta(t)
s = datetime.datetime.combine(created_at, datetime.time.min)
e = datetime.datetime.combine(created_at, datetime.time.max)
pic = models.DesktopPicInfo.objects.filter(class_uuid=class_uuid,
created_at__range=(s,
e))
if lesson_period_sequence:
pic = pic.filter(lesson_period_sequence=lesson_period_sequence)
ret[str(created_at)] = pic.count()
return create_success_dict(data=ret)
return create_failure_dict(msg='获取参数失败！')
def restore(request, *args, **kwargs):
if request.method == 'POST':
if not is_admin(request.current_user):
return create_failure_dict(msg='只有系统管理员admin才能执行此操作！')
try:
f = request.FILES.get('excel')
data = ''
for chunk in f.chunks():
data += chunk
data = bz2.decompress(data)
lines = data.split('\n')
# 清空数据库
_truncate_tables()
meta = {}
for line in lines:
if len(line) == 0:
continue
if line.startswith('meta:'):
# print line
meta = json.loads(line[5:])
else:
models.SyncLogPack.unpack_log('add', line)
# 清空SyncLog
models.SyncLog.objects.all().delete()
# 设置SyncLog AUTO_INCREMENT
cursor = connection.cursor()
n = meta['last_upload_id'] + 1
cursor.execute('ALTER TABLE SyncLog AUTO_INCREMENT=%d' % n)
return create_success_dict(msg='数据恢复成功！')
except:
traceback.print_exc()
def list_current_class(request, *args, **kwargs):
page_info = get_page_info(request)
school_uuid = request.GET.get('school_uuid')
q = models.LessonName.objects.filter(deleted=False)
if school_uuid:
q = q.filter(school__uuid=school_uuid)
# MH:filter if class is selected
# MH:return q.filter if lesson_name is exist
try:
class_uuid = request.GET.get('class_uuid')
if class_uuid:
c = models.LessonSchedule.objects.filter(deleted=False)
lesson_name = c.filter(
class_uuid=class_uuid).values('lesson_name_uuid')
if lesson_name:
q = q.filter(lesson_name__uuid__in=lesson_name)
except:
pass
if models.Setting.getvalue('server_type') == 'school':
#q = q.values('uuid', 'name')
q = q.values('uuid', 'name', 'types')
else:
q = q.order_by().values('name').distinct()
page_data = db_utils.pagination(q, **page_info)
return create_success_dict(
data={
'records': model_list_to_dict(page_data['records']),
'page': page_data['page_num'],
'page_size': page_data['page_size'],
'record_count': page_data['record_count'],
'page_count': page_data['page_count'],
})
def get_pics_info_by_date(request, *args, **kwargs):
"""班班通桌面使用日志，用于返回请求日期的图片信息"""
date = request.GET.get('date', None)
class_uuid = request.GET.get('class_uuid', None)
lesson_period_sequence = request.GET.get('lesson_period_sequence', None)
if date and class_uuid:
date = parse_date(date)
s = datetime.datetime.combine(date, datetime.time.min)
e = datetime.datetime.combine(date, datetime.time.max)
pic = models.DesktopPicInfo.objects.filter(class_uuid__uuid=class_uuid)
pic = pic.filter(created_at__range=(s, e))
if lesson_period_sequence:
pic = pic.filter(lesson_period_sequence=lesson_period_sequence)
pic = pic.values('grade__name', 'class_uuid__name', 'lesson_name',
'teacher_name', 'lesson_period_sequence',
'created_at', 'host', 'url').order_by('created_at')
q = []
for i in pic:
d = {}
d['grade_name'] = i['grade__name']
d['class_name'] = i['class_uuid__name']
d['lesson_name'] = i['lesson_name']
d['teacher_name'] = i['teacher_name']
d['lesson_period_sequence'] = i['lesson_period_sequence']
d['created_at'] = i['created_at']
d['host'] = i['host']
d['url'] = i['url']
q.append(d)
return create_success_dict(data={'records': q})
return create_failure_dict(msg='获取参数失败！')
def set(request, *args, **kwargs):
if request.method == 'POST':
host = request.POST.get('host')
port = request.POST.get('port')
show_download_btn = request.POST.get('show_download_btn', False)
html_title = request.POST.get('html_title')
if host:
i, c = models.Setting.objects.get_or_create(name='host')
if i.value != host:
i.value = host
i.save()
if port:
i, c = models.Setting.objects.get_or_create(name='port')
if i.value != port:
i.value = port
i.save()
obj, c = models.Setting.objects.get_or_create(name='show_download_btn')
obj.value = show_download_btn == 'true' and True or False
obj.save()
if html_title:
obj, c = models.Setting.objects.get_or_create(name='html_title')
obj.value = html_title
obj.save()
install._package_client_file()
return create_success_dict(msg='修改成功')
def _result(request, cache_key, fields):
page_info = get_page_info(request)
start_date = request.GET.get('start_date')
end_date = request.GET.get('end_date')
school_year = request.GET.get('school_year')
term_type = request.GET.get('term_type')
cache.set(cache_key, json.dumps(request.GET), None)
q, total_teachers, active_teachers, title = teacher_active_query(
request.GET)
q = q.values(*fields)
q = q.annotate(total_teachers=Count('teacher', distinct=True))
paginator = Paginator(q, page_info['page_size'])
records = list(paginator.page(page_info['page_num']).object_list)
records = format_record.teacher_active(records, total_teachers, start_date,
end_date, school_year, term_type)
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': records,
'total': {
'total_teachers': total_teachers.count(),
'active_teachers': active_teachers
},
})
return ret
def add(request, *args, **kwargs):
if request.method == 'POST':
host = request.POST.get('host')
port = request.POST.get('port')
key = request.POST.get('key')
# show_download_btn = request.POST.get('show_download_btn', False)
# 根据 host port key 取得该校级服务器在上级服务器中的node_id
node_id = models.Setting.get_node_id_from_top(host, port, key)
if node_id:
obj, c = models.Setting.objects.get_or_create(name='sync_node_id')
obj.value = node_id
obj.save()
else:
logger.exception('')
return create_failure_dict(msg='获取本服务器在上级服务的NODE ID失败')
obj, c = models.Setting.objects.get_or_create(name='sync_server_host')
obj.value = host
obj.save()
obj, c = models.Setting.objects.get_or_create(name='sync_server_port')
obj.value = port
obj.save()
obj, c = models.Setting.objects.get_or_create(name='sync_server_key')
obj.value = key
obj.save()
# 删除token，使得服务器在同步时重新login，上级重新生成<id>.node文件
models.Setting.objects.filter(name='sync_server_token').delete()
return create_success_dict(msg='上级服务器设置成功！')
def edit(request):
'''
教学点管理>编辑
'''
if request.method == 'POST':
if Setting.getvalue('server_type') != 'country':
return create_failure_dict(msg='教学点仅支持县级服务器')
id = request.POST.get('uuid')
obj = EduPoint.objects.get(id=id)
f = EduPointEditForm(request.POST, instance=obj)
if f.is_valid():
number = f.cleaned_data['number']
remark = f.cleaned_data['remark']
if number < obj.number:
return create_failure_dict(msg='教学点修改终端数量不能小于原始数量')
obj.number = number
obj.remark = remark
obj.save()
return create_success_dict(msg='成功编辑教学点')
return create_failure_dict(msg='教学点添加失败', errors=f.errors)
def get_remain_time(request):
'''获取每个班级的剩余可分配课时'''
if request.method == 'GET':
data = request.GET
else:
data = request.POST
grade_name = data.get('grade_name')
class_name = data.get('class_name')
try:
term = models.Term.get_current_term_list()[0]
class_obj = models.Class.objects.get(name=class_name,
grade__name=grade_name,
grade__term=term)
except Exception as e:
logger.exception(e)
return create_failure_dict(msg='错误的班级名称')
remain_time = class_obj.cala_remain_time()
return create_success_dict(
data={
'grade_name': class_obj.grade.name,
'class_name': class_obj.name,
'remain_time': remain_time
})
def delete(request, *args, **kwargs):
"""
教学点管理>删除节点
"""
if request.method == 'POST':
if not cache.get('sudo'):
return create_failure_dict(msg='请输入正确的超级管理员admin密码！')
if Setting.getvalue('server_type') != 'country':
return create_failure_dict(msg='教学点仅支持县级服务器')
id = request.POST.get('uuid')
try:
obj = EduPoint.objects.get(id=id)
except Exception, e:
logger.exception(e)
return create_failure_dict(msg='无该教学点ID, 不能删除')
# 如果该教学点下的教室有已申报的情况，需要提示先取消申报才可删除教学点
if not obj.has_delete():
return create_failure_dict(msg='先解除终端绑定,才能删除教学点！')
obj.delete()
return create_success_dict(msg='成功删除教学点')
def edit_school_post(request):
'''
编辑校园公告
'''
if models.Setting.getvalue('server_type') != 'school':
return create_failure_dict(msg='仅校服务器可用')
if request.method == 'POST':
id = request.POST.get('id', None)
title = request.POST.get('title', '').strip()
content = request.POST.get('content', '').strip()
active = request.POST.get('active', False)
try:
obj = models.SchoolPost.objects.get(pk=id)
except Exception:
return create_failure_dict(msg=u'没有该校园公告')
obj.title = title
obj.content = content
obj.active = active
obj.save()
return create_success_dict(msg=u'编辑校园公告成功')
return create_failure_dict(msg=u'编辑校园公告失败')
def resource_catalog_add(request):
'''
教学点对应的卫星资源接收目录添加
'''
if request.method == 'POST':
if Setting.getvalue('server_type') != 'country':
return create_failure_dict(msg='教学点仅支持县级服务器')
f = EduPointResourceCatalogForm(request.POST)
if f.is_valid():
catalog = f.cleaned_data['catalog']
edupoint_id = request.POST.get('edupoint_id')
try:
edupoint = EduPoint.objects.get(id=edupoint_id)
except Exception, e:
logger.exception(e)
return create_failure_dict(msg='无该教学点ID')
if edupoint.edupointresourcecatalog_set.all().count() >= 10:
return create_failure_dict(msg='教学点只能拥有10个资源接收目录')
obj, c = EduPointResourceCatalog.objects.get_or_create(edupoint=edupoint, catalog=catalog)
if not c:
return create_failure_dict(msg='教学点不能保存相同的资源接收目录')
return create_success_dict(msg='成功添加教学点卫星资源接收目录')
