def add(request, *args, **kwargs):
"""资产报修"""
# TODO 2015-03-23
# 表单添加字段
# 所属位置（常规教室（年级，班级，其他（文本框手动输入））
if models.Setting.getvalue('server_type') != 'school':
return
if request.method == 'POST':
try:
record = AssetRepairForm(request.POST)
if record.is_valid():
a = record.save(commit=False)
a.reported_by = request.current_user.username
school = models.Group.objects.get(group_type='school')
a.school = school
a.school_name = school.name
town, town_name = school.get_town()
a.town = town
a.town_name = town_name
a.country_name = school.get_country_name()
a.save(force_insert=True)
data = model_to_dict(a)
data['asset_type__name'] = data['asset_type']['name']
return create_success_dict(msg='资产报修成功！', data=data)
return create_failure_dict(msg='资产报修失败！', errors=record.errors)
except:
traceback.print_exc()
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 edit(request, *args, **kwargs):
# 如果编辑教师时，修改教师的生日，导致(name, birthday, school)
# 与已删除的隐藏记录重复，这里先删掉隐藏教师。
if request.method == 'POST':
try:
uu = request.POST.get('uuid')
record = models.Teacher.objects.get(uuid=uu)
except:
traceback.print_exc()
return create_failure_dict(msg='错误的uuid！')
teacher_form = TeacherForm(request.POST, instance=record)
if teacher_form.is_valid():
teacher = teacher_form.save(commit=False)
school = models.Group.objects.get(group_type='school')
teacher.school = school
try:
teacher.save()
except IntegrityError, e:
if 'Duplicate entry' in str(e):
return create_failure_dict(msg='已存在同名且同生日的教师')
old = models.Teacher.objects.get(name=teacher.name,
school=school,
birthday=teacher.birthday,
deleted=True)
old.delete()
teacher.save()
except Exception as e:
traceback.print_exc()
return create_failure_dict(msg='服务器错误', debug=str(e))
return create_success_dict(msg='编辑教师成功！',
data=model_to_dict(teacher))
def add(request, *args, **kwargs):
if request.method == 'POST':
lesson_name_form = LessonNameForm(request.POST)
if lesson_name_form.is_valid():
obj = lesson_name_form.save()
return create_success_dict(msg='添加课程成功！', data=model_to_dict(obj))
return create_failure_dict(msg='添加课程失败！',
errors=lesson_name_form.errors)
def add(request, *args, **kwargs):
if request.method == 'POST':
f = NodeForm(request.POST)
if f.is_valid():
node = f.save()
return create_success_dict(msg='添加服务器成功！',
data=model_to_dict(node))
return create_failure_dict(msg='添加服务器失败！', errors=f.errors)
def detail(request, *args, **kwargs):
if request.method == 'GET':
try:
uu = request.GET.get('uuid')
obj = models.Teacher.objects.get(uuid=uu)
data = model_to_dict(obj)
return create_success_dict(data=data)
except:
return create_failure_dict(msg='错误的uuid！')
def add(request, *args, **kwargs):
if request.method == 'POST':
record = TermForm(request.POST)
if record.is_valid():
term = record.save(commit=False)
school = models.Group.objects.get(group_type='school')
term.school = school
term.save()
return create_success_dict(msg='添加学期成功！', data=model_to_dict(term))
return create_failure_dict(msg='添加学期失败！', errors=record.errors)
def edit(request, *args, **kwargs):
if request.method == 'POST':
try:
pk = request.POST.get('id')
node = models.Node.objects.get(id=pk)
f = NodeForm(request.POST, instance=node)
if f.is_valid():
node = f.save()
return create_success_dict(msg=u'编辑成功！',
data=model_to_dict(node))
return create_failure_dict(msg=u'操作失败', errors=f.errors)
except Exception as e:
return create_failure_dict(msg='操作失败', debug=str(e))
def detail(request):
if request.method == 'GET':
try:
uu = request.GET.get('uuid')
u = models.User.objects.filter(uuid=uu)[0]
p = models.UserPermittedGroup.objects.filter(user=u)
p = p.values('uuid', 'group__uuid', 'group__name')
data = {
'user': model_to_dict(u),
'permitted_groups': model_list_to_dict(p)
}
return create_success_dict(data=data)
except:
return create_failure_dict(msg='错误的uuid！')
def add(request, *args, **kwargs):
if request.method == 'POST':
role_form = RoleForm(request.POST)
privileges = request.POST.get('privileges').split(',')
if role_form.is_valid():
role = role_form.save()
for p in privileges:
record = models.RolePrivilege(role=role, privilege=p)
record.save()
return create_success_dict(msg='添加角色成功！', data=model_to_dict(role))
return create_failure_dict(msg='添加角色失败！', errors=role_form.errors)
def details(request, *args, **kwargs):
timelog = []
timelog.append({'start': str(datetime.datetime.now())})
curruser = model_to_dict(request.current_user)
timelog.append({'1': str(datetime.datetime.now())})
k = 'permitted-groups-%s' % curruser['uuid']
v = cache.get(k)
if v:
curruser['permitted_groups'] = cPickle.loads(v)
else:
q = models.Group.objects.filter(
userpermittedgroup__user=curruser['uuid'])
curruser['permitted_groups'] = model_list_to_dict(q)
v = cPickle.dumps(curruser['permitted_groups'],
cPickle.HIGHEST_PROTOCOL)
cache.set(k, v, get_timeout(k, None))
timelog.append({'3': str(datetime.datetime.now())})
curruser['role_name'] = ''
curruser['privileges'] = []
curruser['superuser'] = False
timelog.append({'4': str(datetime.datetime.now())})
if is_admin(request.current_user):
curruser['role_name'] = '超级管理员'
curruser['superuser'] = True
timelog.append({'5-11': str(datetime.datetime.now())})
server_type = models.Setting.getvalue('server_type')
timelog.append({'5-12': str(datetime.datetime.now())})
if server_type not in settings_privileges.PRIVILEGES:
privileges = copy.deepcopy(
settings_privileges.PRIVILEGES['school'])
else:
privileges = copy.deepcopy(
settings_privileges.PRIVILEGES[server_type])
timelog.append({'5-13': str(datetime.datetime.now())})
curruser['privileges'] = get_all_privilege_keys(privileges)
timelog.append({'5-14': str(datetime.datetime.now())})
else:
if request.current_user.role:
curruser['role_name'] = request.current_user.role.name
timelog.append({'5-21': str(datetime.datetime.now())})
rp = request.current_user.role.roleprivilege_set.all()
timelog.append({'5-22': str(datetime.datetime.now())})
curruser['privileges'] = [i.privilege for i in rp]
timelog.append({'5-23': str(datetime.datetime.now())})
timelog.append({'end': str(datetime.datetime.now())})
return create_success_dict(data=curruser, timelog=timelog)
def edit(request, *args, **kwargs):
if request.method == 'POST':
try:
uu = request.POST.get('uuid')
obj = models.NewTerm.objects.get(uuid=uu)
record_form = NewTermForm(request.POST, instance=obj)
if record_form.is_valid():
term = record_form.save()
return create_success_dict(msg='编辑学期成功！',
data=model_to_dict(term))
return create_failure_dict(msg='编辑学期失败！',
errors=record_form.errors)
except:
return create_failure_dict(msg='错误的uuid！')
def add(request, *args, **kwargs):
if request.method == 'POST':
record = AssetForm(request.POST)
if record.is_valid():
asset = record.save(commit=False)
asset.school = models.Group.objects.get(group_type='school')
asset.reported_by = request.current_user.username
try:
asset.save()
except django.db.DataError, e:
# print dir(e)
if 'Out of range value' in str(e):
return create_failure_dict(msg=u'申报数目过大', debug=str(e))
return create_failure_dict(msg=str(e), debug=str(e))
except StandardError, e:
# print type(e), dir(e)
# print e.args
# print e.message
return create_failure_dict(msg='StandardError', debug=str(e))
# 插入一条申报记录
log = models.AssetLog()
town = asset.school.parent
town_name = town.name
if town.group_type != 'town':
town = None
town_name = ''
log.town = town
try:
country_name = town.parent.name
except:
country_name = ''
log.country_name = country_name
log.town_name = town_name
log.school = asset.school
log.school_name = asset.school.name
log.log_type = '新增'
log.asset_type = asset.asset_type
log.asset_from = asset.asset_from
log.device_model = asset.device_model
log.number = asset.number
log.reported_by = asset.reported_by
log.remark = asset.remark
log.save()
return create_success_dict(msg='成功申报资产！',
data=model_to_dict(asset))
def edit(request, *args, **kwargs):
if request.method == 'POST':
uu = request.POST.get('uuid')
record = models.Role.objects.get(uuid=uu)
role_form = RoleForm(request.POST, instance=record)
privileges = request.POST.get('privileges').split(',')
if role_form.is_valid():
role = role_form.save()
role.roleprivilege_set.all().delete()
for p in privileges:
record = models.RolePrivilege(role=role, privilege=p)
record.save()
return create_success_dict(msg='编辑角色成功！', data=model_to_dict(role))
return create_failure_dict(msg='编辑角色失败！', errors=role_form.errors)
def add(request, *args, **kwargs):
if request.method == 'POST':
user_form = UserForm(request.POST)
permitted_groups = request.POST.get('permitted_groups').split(',')
if user_form.is_valid():
user = user_form.save()
for group_uuid in permitted_groups:
try:
group = models.Group.objects.get(uuid=group_uuid)
record = models.UserPermittedGroup(user=user, group=group)
record.save()
except:
pass
data = model_to_dict(user)
if 'role' in data:
if 'name' in data['role']:
data['role__name'] = data['role']['name']
return create_success_dict(msg='添加用户成功！', data=data)
return create_failure_dict(msg='添加用户失败！', errors=user_form.errors)
def edit(request, *args, **kwargs):
if request.method == 'POST':
try:
uu = request.POST.get('uuid')
user = models.User.objects.get(uuid=uu)
if is_admin(user):
role = request.POST.get('role', None)
status = request.POST.get('status', None)
if role:
return create_failure_dict(msg='不允许修改超级管理员用户的角色')
if status == 'suspended':
return create_failure_dict(msg='超级管理员用户不可停用')
user_form = UserForm(request.POST, instance=user)
groups = request.POST.get('permitted_groups').split(',')
if user_form.is_valid():
u = user_form.save()
u.userpermittedgroup_set.all().delete()
for i in groups:
try:
g = models.Group.objects.get(uuid=i)
user = models.UserPermittedGroup(user=u, group=g)
user.save()
except:
pass
k = 'permitted-groups-%s' % uu
cache.delete(k)
k = 'group-%s' % uu
cache.delete(k)
data = model_to_dict(u)
if data['role']:
data['role__name'] = u.role.name
return create_success_dict(msg='编辑用户成功！', data=data)
return create_failure_dict(msg='编辑用户失败！', errors=user_form.errors)
except:
traceback.print_exc()
return create_failure_dict(msg='错误的uuid！')
def list_current_or_next(request, *args, **kwargs):
o = models.NewTerm.get_current_or_next_term()
if not o:
o = {}
return create_success_dict(data=model_to_dict(o))
def remote_get(request):
'''
远程获取大纲内容
1.保存 syllabusgradelesson内容;
2.保存 syllabusgradelessoncontent内容;
'''
term_uuid = request.POST.get('term_uuid', u'')
publish = request.POST.get('publish', u'')
grade_name = request.POST.get('syllabus_grade', u'')
lesson_name = request.POST.get('lesson_name', u'')
bookversion = request.POST.get('date', u'')
#remark = request.POST.get('remark', u'')
#cover_pic = request.POST.get('cover_pic', u'')
#version_pic = request.POST.get('version_pic', u'')
# 1. 保存 syllabusgrade 内容 , 已存在的年级直接读取
try:
t = models.NewTerm.objects.get(uuid=term_uuid)
except:
return create_failure_dict(msg='错误的学年学期')
grade = models.SyllabusGrade.objects.get(school_year=t.school_year,
term_type=t.term_type,
grade_name=grade_name)
# 2. 保存 syllabusgradelessoncontent内容
year, month, number = bookversion.split('-')
# 调用远程接口来获取大纲内容并保存
url = '%s/view/api/syllabus/list-by-bookversion/' % (
constants.RESOURCE_PLATFORM_HOST)
data = {
'lessonname': lesson_name,
#'volume': u'上册' if t.term_type == u'秋季学期' else u'下册',
'school_year': t.school_year,
'term_type': t.term_type,
'grade_name': grade_name,
'publish': publish,
'year': year,
'month': month,
'number': number
}
try:
ret = requests.get(url, params=data, timeout=120)
ret = ret.json()
data = ret.get('data', None)
if data:
remark = data.get('remark', '')
cover_pic = data.get('cover_pic', '')
version_pic = data.get('version_pic', '')
volume = data.get('volume', '')
records = data.get('records', [])
# 2.1 保存 syllabusgradelesson 内容 , 已存在的课程直接读取
lesson, c = models.SyllabusGradeLesson.objects.get_or_create(
syllabus_grade=grade,
lesson_name=lesson_name,
publish=publish,
bookversion=bookversion,
defaults={
'remark': remark,
'picture_host': cover_pic,
'picture_url': version_pic,
'edition': publish
})
if not c:
return create_failure_dict(msg='不能添加重复课程')
if lesson.in_use:
return create_failure_dict(msg='已启用的课程不能拉取教材大纲数据')
# 根据资源平台传递过来的大纲册来回写班班通该字段
if volume:
lesson.volume = volume
lesson.save()
# 先删除原来的
lesson.syllabusgradelessoncontent_set.all().delete()
# 先处理一下拉取过来的大纲数据，它们有父子关系
parent_dict = {}
for record in records:
id = record['id']
title = record['title']
seq = record['seq']
subseq = record['subseq']
parent = record['parent']
# 保存父
if not parent:
obj = models.SyllabusGradeLessonContent.objects.create(
syllabus_grade_lesson=lesson,
title=title,
seq=seq,
subseq=subseq)
parent_dict[id] = obj
for record in records:
title = record['title']
seq = record['seq']
subseq = record['subseq']
parent = record['parent']
# 保存子
if parent:
parent = parent_dict[parent]
models.SyllabusGradeLessonContent.objects.create(
syllabus_grade_lesson=lesson,
title=title,
parent=parent,
seq=seq,
subseq=subseq)
return create_success_dict(data={'records': model_to_dict(lesson)})
return create_failure_dict(msg='无合适课程教学大纲拉取')
except Exception:
traceback.print_exc()
return create_failure_dict(msg='课程教学大纲拉取失败')
