def get(user): k = 'group-%s' % user.uuid v = cache.get(k) if v: data = cPickle.loads(v) data['cache'] = 'hit' return data data = {'group': [], 'grade': [], 'cache': 'miss'} server_type = models.Setting.getvalue('server_type') q = models.Group.objects.all() if server_type != 'school': if not is_admin(user): q = q.filter(uuid__in=user.permitted_groups.all()) else: school = models.Group.objects.filter(group_type='school') terms = models.Term.get_current_term_list(school) grades = models.Grade.objects.filter(term__in=terms) grades = grades.values('uuid', 'name', 'term__school__uuid') data['grade'] = model_list_to_dict(grades) q = q.values('uuid', 'name', 'group_type', 'parent__uuid') data['group'] = model_list_to_dict(q) for d in data['group']: py = pypinyin.pinyin(d['name'], pypinyin.FIRST_LETTER) d['first_letter'] = ''.join([i[0] for i in py]) py = ' '.join(pypinyin.lazy_pinyin(d['name'], pypinyin.TONE2)) d['pinyin'] = py cache.set(k, cPickle.dumps(data, cPickle.HIGHEST_PROTOCOL), get_timeout(k, None)) return data
def info(request, *args, **kwargs): d = {} # 缓存使用状况 d['classes_last_active_time'] = cache.get('classes_last_active_time') d['classes'] = cache.get('classes') # 数据库状态 q = models.Setting.objects.all() d['setting'] = model_list_to_dict(q) if models.Setting.getvalue('server_type') == 'school': q = models.Group.objects.all() d['group'] = model_list_to_dict(q) q = models.SyncLog.objects.count() d['synclog_count'] = q return create_success_dict(data=d)
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 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 get_lesson_period(request): ret = datetimeutil.get_term_from_date_range(request) if isinstance(ret, (str, unicode)): return create_failure_dict(msg=ret) q = models.LessonPeriod.objects.filter(term=ret) q = q.values('uuid', 'sequence') return create_success_dict(data={'lesson_period': model_list_to_dict(q)})
def lesson_list(request): #pk = request.GET.get('id') grade_name = request.GET.get('grade_name', '') term_uuid = request.GET.get('term_uuid', '') try: t = models.NewTerm.objects.get(uuid=term_uuid) except: return create_failure_dict(msg='错误的学年学期') # 保存syllabusgrade try: obj, c = models.SyllabusGrade.objects.get_or_create( school_year=t.school_year, term_type=t.term_type, grade_name=grade_name, defaults={'in_use': False}) except: return create_failure_dict(msg='错误的班级信息') q = models.SyllabusGradeLesson.objects.filter(syllabus_grade=obj) q = q.values() return create_success_dict( data={ 'records': model_list_to_dict(q), 'host': 'http://oebbt-cover.qiniudn.com', 'RESOURCE_PLATFORM_HOST': constants.RESOURCE_PLATFORM_HOST })
def get_teachers_lessons(class_uuid): q = models.LessonTeacher.objects.filter(class_uuid=class_uuid) q = q.values('teacher__uuid', 'teacher__name', 'lesson_name__name') ret = model_list_to_dict(q) return ret key = 'simplecache_lesson_teacher_%s' % class_uuid.uuid c = cache.get(key) if c: ret = json.loads(c) else: q = models.LessonTeacher.objects.filter(class_uuid=class_uuid) q = q.values('teacher__uuid', 'teacher__name', 'lesson_name__name') ret = model_list_to_dict(q) cache.set(key, json.dumps(ret), get_timeout(key, None)) return ret
def update_class_weekday(grade_name, class_name, weekday): ''' lessonschedule-class-week: [ { 'lesson_name__name': 'fdsfds', 'lesson_period__sequence': 1, 'lesson_period__start_time': 'hh:mm:ss', 'lesson_period__end_time': 'hh:mm:ss', }, {...}, {...}, ] ''' try: term = models.Term.get_current_term_list()[0] except: return try: c = models.Class.objects.get(grade__term=term, grade__name=grade_name, name=class_name) except: return q = models.LessonSchedule.objects.all() q = q.filter(class_uuid=c, weekday=weekday) k = 'lessonschedule-%s-%s' % (c.uuid, weekday) cache.delete(k) q = q.filter(weekday=weekday).values('uuid', 'lesson_name__name', 'lesson_period__uuid', 'lesson_period__sequence', 'lesson_period__start_time', 'lesson_period__end_time') q = q.order_by('lesson_period__sequence') v = json.dumps(model_list_to_dict(q), cls=RevisedDjangoJSONEncoder) cache.set(k, v, get_timeout(k, 60 * 60 * 24))
def force_index_query(page_info): timelog = [] timelog.append({'start': str(datetime.datetime.now())}) sql = '''SELECT uuid, province_name, city_name, country_name, town_name, school_name, grade_name, class_name, teacher_name, lesson_period_sequence, lesson_name, created_at FROM TeacherLoginLog FORCE INDEX (TeacherLoginLog_96511a37) ORDER BY created_at DESC LIMIT %s OFFSET %s''' limit = page_info['page_size'] offset = limit * (page_info['page_num'] - 1) q = models.TeacherLoginLog.objects.raw(sql, [limit, offset]) timelog.append({'1': str(datetime.datetime.now())}) count = models.TeacherLoginLog.objects.count() timelog.append({'2': str(datetime.datetime.now())}) records = model_list_to_dict(q) timelog.append({'3': str(datetime.datetime.now())}) if page_info['page_num'] != 1: records = format_record.activity_logged_in_force_index(records) timelog.append({'4': str(datetime.datetime.now())}) data = { 'records': records, 'page': 1, 'page_size': 25, 'record_count': count, 'page_count': (count + 25) / 25, 'timelog': timelog, } timelog.append({'end': str(datetime.datetime.now())}) return data
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 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 _update(uu): key = 'simplecache_lesson_teacher_%s' % uu cache.delete(key) q = models.LessonTeacher.objects.filter(class_uuid=uu) q = q.values('teacher__uuid', 'teacher__name', 'lesson_name__name') ret = model_list_to_dict(q) cache.set(key, json.dumps(ret), get_timeout(key, None))
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 content_list(request): pk = request.GET.get('id') q = models.SyllabusGradeLessonContent.objects.filter( syllabus_grade_lesson=pk) q = q.values().order_by('seq', 'subseq') q = format_record.syllabus_content_list(q) return create_success_dict(data={'records': model_list_to_dict(q)})
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 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 import_from(request, *args, **kwargs): if request.method == 'POST': f = TermUploadForm(request.POST, request.FILES) if f.is_valid(): terms = f.save() return create_success_dict(data=model_list_to_dict(terms)) return create_failure_dict(msg='导入学年学期失败!', errors=f.errors)
def get_devicemodel_by_assettype(request, *args, **kwargs): uu = request.GET.get('uuid') try: q = models.Asset.objects.filter(asset_type__uuid=uu) q = q.values('device_model').distinct() return create_success_dict(data={'records': model_list_to_dict(q)}) except: logger.exception('')
def verify(request, *args, **kwargs): if request.method == 'POST': f = LessonNameUploadVerifyForm(request.POST, request.FILES) if f.is_valid(): objs = f.save() return create_success_dict(data=model_list_to_dict(objs)) return create_failure_dict(msg='验证学校开课课程失败!', errors=f.errors)
def import_from(request, *args, **kwargs): if request.method == 'POST': f = LessonNameUploadForm(request.POST, request.FILES) if f.is_valid(): lesson_names = f.save() return create_success_dict(data=model_list_to_dict(lesson_names)) return create_failure_dict(msg='导入学校开课课程失败!', errors=f.errors)
def list_current(request, *args, **kwargs): page_info = get_page_info(request) school_year = request.GET.get('school_year') term_type = request.GET.get('term_type') # terms = models.Term.get_current_term_list() terms = models.Term.objects.filter(deleted=False) q = models.LessonPeriod.objects.filter(term__in=terms) if models.Setting.getvalue('server_type') != 'school': q = q.order_by().values('sequence').distinct() return create_success_dict(data={'records': model_list_to_dict(q)}) else: if not is_admin(request.current_user): if not request.current_user.role: return create_failure_dict(status='permission_denied', msg='您没有权限访问当前功能!') count = request.current_user.role.roleprivilege_set count = count.filter(privilege='system_lesson_period').count() if count == 0: return create_failure_dict(status='permission_denied', msg='您没有权限访问当前功能!') if school_year: q = q.filter(school_year=school_year) if term_type: q = q.filter(term_type=term_type) q = q.values('uuid', 'term__school_year', 'term__term_type', 'sequence', 'start_time', 'end_time') page_data = db_utils.pagination(q, **page_info) 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'], } try: term = models.Term.get_current_term_list()[0] max_sequence = models.LessonPeriod.objects.filter(term=term) max_sequence = max_sequence.aggregate(Max('sequence')) # print max_sequence data['max_sequence'] = max_sequence['sequence__max'] except: pass return create_success_dict(data=data)
def courseware_list(request): pk = request.GET.get('id') teacherloginlog_uuids = models.TeacherLoginLogLessonContent.objects.filter( lessoncontent=pk).values_list('teacherloginlog', flat=True) q = models.TeacherLoginLogCourseWare.objects.filter( teacherloginlog__in=teacherloginlog_uuids) q = q.values('courseware__title', 'courseware__qiniu_url').distinct() return create_success_dict(data={'records': model_list_to_dict(q)})
def get_grade_class(request): ret = datetimeutil.get_term_from_date_range(request) computerclass_need = request.GET.get('computerclass_need', False) only_computerclass = request.GET.get('only_computerclass', False) if isinstance(ret, (str, unicode)): return create_failure_dict(msg=ret) grades = models.Grade.objects.filter(term=ret) if only_computerclass == 'true': # 仅需要电脑教室的联动信息 grades = grades.filter(number=13) elif computerclass_need != 'true': # 仅需要普通年级班级的联动信息 grades = grades.exclude(number=13) classes = models.Class.objects.filter(grade__in=grades) data = { 'grade': model_list_to_dict(grades.values('uuid', 'name')), 'class': model_list_to_dict(classes.values('uuid', 'name', 'grade')) } return create_success_dict(data=data)
def verify(request, *args, **kwargs): if request.method == 'POST': f = LessonTeacherUploadVerifyForm(request.POST, request.FILES) if f.is_valid(): objs = f.save() return create_success_dict( data={'records': model_list_to_dict(objs)}) return create_failure_dict(msg='验证班级课程授课老师失败!', errors=f.errors)
def verify(request, *args, **kwargs): if request.method == 'POST': try: f = TeacherUploadVerifyForm(request.POST, request.FILES) if f.is_valid(): objs = f.save() return create_success_dict(data=model_list_to_dict(objs)) return create_failure_dict(msg='验证教职人员基础信息失败!', errors=f.errors) except: traceback.print_exc()
def list_current(request, *args, **kwargs): uuid = request.GET.get('uuid') q = models.LessonSchedule.objects.all() q = q.filter(class_uuid__grade__term__deleted=False) if uuid: q = q.filter(class_uuid=uuid) q = q.values('uuid', 'class_uuid', 'lesson_period__uuid', 'lesson_period__sequence', 'lesson_period__start_time', 'lesson_period__end_time', 'weekday', 'lesson_name__name') return create_success_dict(data={'records': model_list_to_dict(q)})
def get(): key = 'simplecache_resource' c = cache.get(key) if c: ret = json.loads(c) else: q = models.Resource.objects.values('resource_from').distinct() ret = model_list_to_dict(q) cache.set(key, json.dumps(ret), get_timeout(key, None)) return ret
def grade_list(request): uu = request.GET.get('uuid') try: t = models.NewTerm.objects.get(uuid=uu) except: return create_failure_dict(msg='错误的uuid') q = models.SyllabusGrade.objects.filter(school_year=t.school_year, term_type=t.term_type) q = q.values('id', 'grade_name', 'in_use') return create_success_dict(data={'records': model_list_to_dict(q)})
def lesson_teacher_import(request, *args, **kwargs): if request.method == 'POST': if models.Setting.getvalue('installed') == 'True': failure = '您已经配置过本服务器,无法重新配置!' return create_failure_dict(msg=failure) f = LessonTeacherUploadForm(request.POST, request.FILES) if f.is_valid(): objs = f.save() return create_success_dict(data=model_list_to_dict(objs)) return create_failure_dict(msg='导入班级课程授课老师失败!', errors=f.errors)
def grade_class_import(request, *args, **kwargs): if request.method == 'POST': if models.Setting.getvalue('installed') == 'True': failure = '您已经配置过本服务器,无法重新配置!' return create_failure_dict(msg=failure) f = ClassUploadForm(request.POST, request.FILES) if f.is_valid(): classes = f.save() return create_success_dict(data=model_list_to_dict(classes)) return create_failure_dict(msg='导入学校年级班级失败!', errors=f.errors)