def get(self, request):
"""
检查是否登录
:param request:
:return:
"""
if self.auth.is_login():
return SuccessResult(id=self.auth.get_account().id)
return SuccessResult(id=None)
def post(self, request, tid):
"""
加入队伍
:param request:
:param tid:
:return:
"""
if AccountTeam.objects.filter(
account=self.auth.get_account()).exists():
raise TeamInfoExcept.already_in_team()
logic = TeamLogic(self.auth, tid)
params = ParamsParser(request.JSON)
# 检查入队密码
password = params.str('password',
desc='入队密码',
default='',
require=False)
if not logic.team.public and password != logic.team.password:
raise TeamInfoExcept.password_error()
# 检查队伍人员是否满员
if logic.team.full:
raise TeamInfoExcept.team_is_full()
with transaction.atomic():
account = AccountTeam.objects.create(
team=logic.team,
account=self.auth.get_account(),
)
if AccountTeam.objects.filter(
team=logic.team).count() >= logic.team.maximum_number:
logic.team.full = True
logic.team.save()
return SuccessResult(id=account.id)
def put(self, request, cid):
"""
修改分类信息
:param request:
:param cid:
:return:
"""
params = ParamsParser(request.JSON)
logic = TaskClassificationLogic(self.auth, cid)
# 环状警告
# if params.has('parent'):
# parent = TaskClassification.objects.get_once(pk=params.int('parent', desc='父节点id'))
# if parent is None:
# raise TaskClassificationExcept.parent_is_not_exists()
classification = logic.classification
with params.diff(classification):
classification.name = params.str(
'name', desc='名称', max_length=MAX_CLASSIFICATION_LENGTH)
classification.description = params.str(
'description', desc='简介', max_length=MAX_DESCRIPETION_LENGTH)
# if params.has('parent'):
# classification.parent = parent
classification.save()
return SuccessResult(id=cid)
def get(self, request, sid, cid):
"""
获取老师对学生评价列表
:param request:
:param sid:
:param cid:
:return:
"""
logic = CourseLogic(self.auth, sid, cid)
params = ParamsParser(request.GET)
limit = params.int('limit', desc='每页最大渲染数', require=False, default=10)
page = params.int('page', desc='当前页数', require=False, default=1)
evaluates = PracticeEvaluateTeacherToStudent.objects.filter(
author=logic.course.author).values('id', 'update_time')
if params.has('star'):
evaluates = evaluates.filter(star=params.int('star', desc='星级'))
if params.has('key'):
key = params.str('key', desc='关键字')
evaluates = evaluates.filter(
Q(student__realname__contains=key)
| Q(student__code__contains=key))
evaluates_list, pagination = slicer(evaluates, limit=limit,
page=page)()()
return SuccessResult(evaluates=evaluates_list, pagination=pagination)
def get(self, request, sid):
"""
获取课程列表
:param request:
:param sid:
:return:
"""
params = ParamsParser(request.GET)
limit = params.int('limit', desc='每页最大渲染数', require=False, default=10)
page = params.int('page', desc='当前页数', require=False, default=1)
courses = PracticeCourse.objects.filter(school_id=sid).values(
'id', 'update_time')
if params.has('name'):
courses = courses.filter(
name__contains=params.str('name', desc='名称'))
if params.has('tag'):
courses = courses.filter(tag_id=params.int('tag', desc='tagid'))
if params.has('start_time'):
courses = courses.filter(
start_time__gte=params.float('start_time', desc='开始时间'))
if params.has('end_time'):
courses = courses.filter(
end_time__lte=params.float('end_time', desc='结束时间'))
courses_list, pagination = slicer(courses, limit=limit, page=page)()()
return SuccessResult(courses=courses_list, pagination=pagination)
def put(self, request, tid, rid):
"""
修改任务汇报
:param request:
:param tid:
:param rid:
:return:
"""
logic = TaskReportLogic(self.auth, tid, rid)
params = ParamsParser(request.JSON)
report = logic.report
with params.diff(report):
report.summary = params.str('summary', desc='总结')
# 关联资源元数据
if params.has('resources'):
meta_list = {ResourceLogic.decode_token(token) for token in params.list('resources', desc='资源信息')}
try:
meta_list.remove(None)
except:
pass
report.resource.set(list(meta_list))
report.save()
return SuccessResult(id=rid)
def post(self, request, sid):
"""
创建课程
:param request:
:param sid:
:return:
"""
params = ParamsParser(request.JSON)
logic = SchoolLogic(self.auth, sid)
try:
with transaction.atomic():
course = PracticeCourse.objects.create(
school=logic.school,
author=self.auth.get_account(),
tag_id=params.int('tag', desc='tagid')
if params.has('tag') else None,
name=params.str('name', desc='课程名称'),
description=params.str('description',
desc='描述',
default='',
require=False),
start_time=params.float('start_time',
desc='开始时间',
default=0.0,
require=False),
end_time=params.float('end_time',
desc='结束时间',
default=0.0,
require=False))
except Exception as ex:
raise PracticeCourseInfoExcept.course_create_fail()
return SuccessResult(id=course.id)
def post(self, request):
"""
登录
:param request:
:return:
"""
# TODO: 后续加上人机验证
params = ParamsParser(request.JSON)
password = params.str('password',
desc='密码',
min_length=MIN_PASSWORD_LENGTH,
max_length=MAX_PASSWORD_LENGTH)
username = params.str('username',
desc='用户名',
max_length=MAX_USERNAME_LENGTH)
accounts = Account.objects.filter_cache(username=username)
# 因为得到的是list类型所以直接使用len即可，不会造成多次数据库io操作
if len(accounts) == 0 or not signatures.compare_password(
password, accounts[0].password):
raise AccountInfoExcept.login_error()
self.auth.set_account(accounts[0])
self.auth.set_session()
return SuccessResult(id=accounts[0].id)
def put(self, request, sid, cid, aid):
"""
修改排课信息
:param request:
:param sid:
:param cid:
:param aid:
:return:
"""
logic = ArrangementLogic(self.auth, sid, cid, aid)
params = ParamsParser(request.JSON)
arrangement = logic.arrangement
with params.diff(arrangement):
arrangement.name = params.str('name', desc='名称')
arrangement.day_of_week = params.int('day_of_week',
desc='周几',
max_value=7,
min_value=0)
arrangement.start_week = params.int('start_week',
desc='开始周',
min_value=0)
arrangement.end_week = params.int('end_week',
desc='结束周',
min_value=0)
arrangement.odd_even = params.int('odd_even', desc='单双周')
arrangement.start_section = params.int('start_section',
min_value=0)
arrangement.end_section = params.int('end_section',
desc='结束节',
min_value=0)
arrangement.start_time = params.float('start_time', desc='开始时间')
arrangement.end_tim = params.float('end_time', desc='结束时间')
arrangement.save()
return SuccessResult(id=aid)
def post(self, request):
"""
完成上传
:param request:
:return:
"""
params = ParamsParser(request.JSON)
token = params.str('token', desc='token')
name = params.str('name', desc='文件名称')
fhash = params.str('hash', desc='文件hash')
meta = ResourcesMeta.objects.filter(hash=fhash)
if meta.exists():
meta = meta[0]
else:
with transaction.atomic():
meta = ResourcesMeta.objects.create(
name=name,
mime=MIME_TYPE.get(name.split('.')[-1], 'text/plain'),
size=params.int('size', desc='文件大小'),
hash=fhash)
logic = ResourceLogic(self.auth, meta)
ok, v_token = logic.upload_finish(token, name)
if not ok:
raise ResourceInfoExcept.upload_fail()
return SuccessResult(token=v_token)
def post(self, request, sid, cid, aid):
"""
批量导入学生信息
:param request:
:param sid:
:param cid:
:param aid:
:return:
"""
logic = ArrangementLogic(self.auth, sid, cid, aid)
slogic = StudentUserLogic(self.auth, sid)
params = ParamsParser(request.JSON)
studentuser_data = params.list('data', desc='导入学生信息')
arrangement = logic.arrangement
for data in studentuser_data:
data_params = ParamsParser(data)
try:
studentuser = slogic.create_studentuser(data_params)
arrangement.students.add(studentuser)
except:
pass
arrangement.save()
return SuccessResult(id=aid)
def get(self, request, sid, cid, aid):
"""
获取排课考勤
:param request:
:param sid:
:param cid:
:param aid:
:return:
"""
params = ParamsParser(request.GET)
limit = params.int('limit', desc='每页最大渲染数', require=False, default=10)
page = params.int('page', desc='当前页数', require=False, default=1)
attendances = PracticeAttendance.objects.filter(
arrangement_id=aid).values('id', 'update_time')
if params.has('leaver'):
attendances = attendances.filter(
leaver__gte=params.int('leaver', desc='请假次数'))
if params.has('absent'):
attendances = attendances.filter(
absent__gte=params.int('absent', desc='缺勤'))
if params.has('late'):
attendances = attendances.filter(
late__gte=params.int('late', desc='迟到'))
if params.has('key'):
attendances = attendances.filter(
student__realname__contains=params.str('key',
desc='关键字（学生姓名）'))
attendance_list, pagination = slicer(attendances,
limit=limit,
page=page)()()
return SuccessResult(attendances=attendance_list,
pagination=pagination)
def put(self, request, tid, aid):
"""
修改任务申请表内容
:param request:
:param tid:
:return:
"""
logic = TaskApplyLogic(self.auth, aid)
params = ParamsParser(request.JSON)
apply = logic.apply
if params.has('exhibition'):
# 成就选择异常 （一般是恶意请求，所以直接报无权限）
exhibitions = AccountExhibition.objects.filter(account=self.auth.get_account()).values('id')
ex_ids = params.list('exhibition')
if not set(ex_ids).issubset([i["id"] for i in exhibitions]):
raise TaskInfoExcept.no_permission()
apply.exhibition.set(ex_ids)
with params.diff(apply):
apply.conte0nt = params.str('content', desc='正文')
apply.save()
return SuccessResult(id=aid)
def post(self, request, tid):
"""
提交任务申请
:param request:
:param tid:
:return:
"""
logic = TaskLogic(self.auth, tid)
params = ParamsParser(request.JSON)
if logic.task.stage != int(TaskStageEnum.RELEASE):
raise TaskInfoExcept.no_permission()
if params.has('exhibition'):
# 成就选择异常 （一般是恶意请求，所以直接报无权限）
exhibitions = AccountExhibition.objects.filter(account=self.auth.get_account()).values('id')
ex_ids = params.list('exhibition', desc='成就id列表')
if not set(ex_ids).issubset([i['id'] for i in exhibitions]):
raise TaskInfoExcept.no_permission()
with transaction.atomic():
apply = TaskApply.objects.create(
task=logic.task,
author=self.auth.get_account(),
content=params.str('content', desc='正文'),
)
if params.has('exhibition'):
apply.exhibition.set(ex_ids)
apply.save()
return SuccessResult(id=apply.id)
def get(self, request, tid):
"""
获取任务申请列表
:param request:
:param tid:
:return:
"""
params = ParamsParser(request.GET)
limit = params.int('limit', desc='每页最大渲染数', require=False, default=10)
page = params.int('page', desc='当前页数', require=False, default=1)
logic = TaskLogic(self.auth, tid)
if logic.task.author != self.auth.get_account() and \
self.auth.get_account().role != int(AccountRoleEnum.ADMIN):
raise TaskInfoExcept.no_permission()
applies = TaskApply.objects.filter(task=logic.task).values(
'id', 'create_time', 'update_time', 'author', 'author__nickname'
).order_by('create_time')
@slicer(applies, limit=limit, page=page)
def get_apply_list(obj):
obj['author'] = {
'id': obj['author'],
'nickname': obj['author__nickname']
}
del obj['author__nickname']
return obj
apply_list, pagination = get_apply_list()
return SuccessResult(applies=apply_list, pagination=pagination)
def post(self, request, sid, cid, aid):
"""
导入考勤情况
主要是因为该系统只是一个附属管理系统
原本应该直接从主系统数据库获取信息
现在只能做导入操作
:param request:
:param sid:
:param cid:
:param aid:
:return:
"""
params = ParamsParser(request.JSON)
data = params.list('data', default='考勤信息')
logic = ArrangementLogic(self.auth, sid, cid, aid)
students = logic.arrangement.students.all()
status = {}
students_info = {student.code: student.id for student in students}
for info in data:
try:
PracticeAttendance.objects.create(school_id=sid,
course_id=cid,
arrangement_id=aid,
student_id=students_info.get(
info.get('code', ''),
-1),
leaver=info.get('leaver', 0),
absent=info.get('absent', 0),
late=info.get('late', 0))
status[info.get('code', '')] = True
except:
status[info.get('code', '')] = False
return SuccessResult(status)
def get(self, request, aid):
"""
获取仪表盘
:param request:
:param aid:
:return:
"""
logic = AccountLogic(self.auth, aid)
# 获取发布任务信息
tasks = Task.objects.filter(author=logic.account).values(
'id', 'title', 'stage', 'task_type', 'create_time')
# 获取接受任务信息
works = logic.account.task_workers_set.all().values(
'id', 'title', 'stage', 'task_type', 'create_time')
data = {'tasks': [i for i in tasks], 'works': [i for i in works]}
# 本人则获取申请任务信息
if logic.account == self.auth.get_account():
apply = TaskApply.objects.filter(author=logic.account).values(
'task__id',
'task__title',
'id',
'create_time',
)
data['apply'] = [i for i in apply]
return SuccessResult(data)
def put(self, request, gid, mid):
"""
修改成员信息
:param request:
:param gid:
:param mid:
:return:
"""
params = ParamsParser(request.JSON)
mapping = FaceUFacialMakeupMapping.objects.filter(group_id=gid, id=mid)
if not mapping.exists():
raise FaceUGroupManageExcept.member_is_not_exists()
mapping = mapping[0]
with params.diff(mapping):
mapping.name = params.str('name', desc='姓名')
mapping.code = params.str('code', desc='标识')
if params.has('face'):
face_uuid = FaceUGroupsLogic.save_face(
params.str('face', desc='脸谱'))
makeup, _ = FaceUFacialMakeup.objects.get_or_create(
face_uuid=face_uuid,
defaults={
"name": mapping.name,
"id_code": "",
"sex": int(AccountSexEnum.UNKNOW)
})
mapping.face = makeup
mapping.save()
return SuccessResult(id=mid)
def delete(self, request, gid):
"""
移除成员
:param request:
:param gid:
:return:
"""
params = ParamsParser(request.JSON)
logic = FaceUGroupsLogic(self.auth, gid)
ids = params.list('ids', desc='成员id列表')
status = {}
mappings = FaceUFacialMakeupMapping.objects.get_many(ids)
for mapping in mappings:
_id = mapping.id
try:
if mapping.group_id == logic.group.id:
mapping.delete()
status[_id] = 1
else:
status[_id] = 0
except:
status[_id] = 0
return SuccessResult(status=status)
def post(self, request, tid):
"""
提交任务汇报
:param request:
:param tid:
:return:
"""
params = ParamsParser(request.JSON)
logic = TaskLogic(self.auth, tid)
if logic.task.leader != self.auth.get_account():
raise TaskReportExcept.no_permission()
# 每个任务有且仅有一个任务汇报
if TaskReport.objects.filter(task=logic.task).exists():
raise TaskReportExcept.report_is_exists()
with transaction.atomic():
report = TaskReport.objects.create(
task=logic.task,
summary=params.str('summary', desc='总结'),
)
# 关联资源元数据
if params.has('resources'):
meta_list = {ResourceLogic.decode_token(token) for token in params.list('resources', desc='资源信息')}
try:
meta_list.remove(None)
except:
pass
report.resource.set(list(meta_list))
# 修改任务阶段至结算期
logic.task.stage = int(TaskStageEnum.SETTLEMENT)
report.save()
return SuccessResult(id=report.id)
def post(self, request, sid):
"""
批量导入教室信息
:param request:
:param sid:
:return:
"""
logic = SchoolLogic(self.auth, sid)
params = ParamsParser(request.JSON)
classrooms = params.list('data', desc='教室信息')
state = {}
for classroom in classrooms:
params_classroom = ParamsParser(classroom)
name = params_classroom.str('name', desc='教室名称')
try:
with transaction.atomic():
PracticeClassroom.objects.create(
school=logic.school,
name=name,
size=params_classroom.int('size', desc='教室大小'),
)
state[name] = 1
except:
state[name] = 0
return SuccessResult(state)
def get(self, request):
"""
获取队伍列表
:param request:
:return:
"""
params = ParamsParser(request.GET)
limit = params.int('limit', desc='每页最大渲染数', require=False, default=10)
page = params.int('page', desc='当前页数', require=False, default=1)
teams = Team.objects.values('id', 'nickname', 'full', 'public',
'leader', 'leader__nickname',
'update_time')
if params.has('nickname'):
teams = teams.filter(
nickname__contains=params.str('nickname', desc='队伍名称'))
if params.has('full'):
teams = teams.filter(full=params.bool('full', desc='是否满员'))
if params.has('public'):
teams = teams.filter(public=params.bool('public', desc='是否公开'))
@slicer(teams, limit=limit, page=page)
def get_team_list(obj):
obj['leader'] = {
'nickname': obj.get('leader__nickname', ''),
'id': obj.get('leader')
}
if 'leader__nickname' in obj: del obj['leader__nickname']
return obj
team_list, pagination = get_team_list()
return SuccessResult(teams=team_list, pagination=pagination)
def post(self, request):
"""
创建任务分类
:param request:
:return:
"""
params = ParamsParser(request.JSON)
if params.has('parent'):
parent = TaskClassification.objects.get_once(
pk=params.int('parent', desc='父节点id'))
if parent is None:
raise TaskClassificationExcept.classification_is_not_exists()
with transaction.atomic():
classification = TaskClassification.objects.create(
name=params.str('name',
desc='分类名称',
max_length=MAX_CLASSIFICATION_LENGTH),
description=params.str('description',
desc='简介',
default='',
require=False,
max_length=MAX_DESCRIPETION_LENGTH),
)
if params.has('parent'):
classification.parent = parent
classification.save()
return SuccessResult(id=classification.id)
def get(self, request):
"""
获取记录列表
:param request:
:return:
"""
params = ParamsParser(request.GET)
limit = params.int('limit', desc='每页最大渲染数', require=False, default=10)
page = params.int('page', desc='当前页数', require=False, default=1)
if self.auth.get_account().role == int(AccountRoleEnum.ADMIN) and \
params.has('account'):
_account = FaceUAccount.objects.get_once(
pk=params.int('account', desc="用户id"))
else:
_account = self.auth.get_account()
record = FaceUDistinguishRecord.objects.filter(author=_account)\
.values('id', 'update_time', 'group_id').order_by('-create_time')
if params.has('group'):
record = record.filter(group_id=params.int('group', desc='分组id'))
if params.has('start_time'):
record = record.filter(
create_time__gte=params.float('start_time', desc='开始时间'))
if params.has('end_time'):
record = record.filter(
create_time__lte=params.float('end_time', desc='结束时间'))
if params.has('overall'):
record = record.filter(
group__isnull=params.bool('overall', desc='全局与否'))
record_list, pagination = slicer(record, limit=limit, page=page)()()
return SuccessResult(records=record_list, pagination=pagination)
def put(self, request, tid):
"""
修改成员角色
:param request:
:param tid:
:return:
"""
logic = TeamLogic(self.auth, tid)
params = ParamsParser(request.JSON)
ids = params.list('ids', desc='成员id列表')
role = params.int('role', desc='角色enum')
# 过滤错误role
if not AccountRoleEnum.has_value(role):
raise TeamInfoExcept.role_error()
status = dict()
accounts = AccountTeam.objects.get_many(pks=ids)
for account in accounts:
if account.team == logic.team:
account.role = role
account.save()
status[str(account.id)] = 1
else:
status[str(account.id)] = 0
return SuccessResult(status=status)
def put(self, request, aid, eid):
"""
修改用户作品信息
:param request:
:param aid:
:param eid:
:return:
"""
params = ParamsParser(request.JSON)
logic = ExhibitionLogic(self.auth, eid)
exhibition = logic.exhibition
with params.diff(exhibition):
exhibition.title = params.str('title', desc='标题')
exhibition.content = params.str('content', desc='正文')
exhibition.show = params.bool('show', desc='是否展示')
# 关联资源元数据
if params.has('resources'):
meta_list = {ResourceLogic.decode_token(token) for token in params.list('resources', desc='资源信息')}
try:
meta_list.remove(None)
except:
pass
exhibition.resource.set(list(meta_list))
exhibition.save()
return SuccessResult(id=eid)
def get(self, request, sid, cid):
"""
获取学生对课程评价列表
:param request:
:param sid:
:param cid:
:return:
"""
params = ParamsParser(request.GET)
limit = params.int('limit', desc='每页最大渲染数', require=False, default=10)
page = params.int('page', desc='当前页数', require=False, default=1)
evaluates = PracticeEvaluateStudentToCourse.objects.filter(
course_id=cid).values('id', 'update_time')
if params.has('star'):
evaluates = evaluates.filter(star=params.int('star', desc='星级'))
if params.has('key'):
key = params.str('key', desc='关键字关键字（学生真实名称、学号）弱匹配')
evaluates = evaluates.filter(
Q(author__realname__contains=key)
| Q(author__code__contains=key))
evaluates_list, pagination = slicer(evaluates, limit=limit,
page=page)()()
return SuccessResult(evaluates=evaluates_list, pagination=pagination)
def get(self, request):
"""
获取任务列表
:param request:
:return:
"""
params = ParamsParser(request.GET)
limit = params.int('limit', desc='每页最大渲染数', require=False, default=10)
page = params.int('page', desc='当前页数', require=False, default=1)
tasks = Task.objects.values('id', 'title', 'task_type', 'stage',
'classification', 'update_time')
if params.has('task_type'):
tasks = tasks.filter(
task_type=params.int('task_type', desc='任务类型'))
if params.has('stage'):
stage = params.int('stage', desc='任务阶段')
if stage == int(TaskStageEnum.RELEASE):
tasks.exclude(publish_end_time__lte=time.time())
tasks = tasks.filter(stage=stage)
if params.has('classification'):
tasks = tasks.filter(
classification_id=params.int('classification', desc='分类id'))
if params.has('title'):
tasks = tasks.filter(
title__contains=params.str('title', desc='标题'))
tasks, pagination = slicer(tasks, limit=limit, page=page)()()
return SuccessResult(tasks=tasks, pagination=pagination)
def post(self, request, aid):
"""
创建个人作品展示
:param request:
:param aid:
:return:
"""
params = ParamsParser(request.JSON)
with transaction.atomic():
exhibition = AccountExhibition.objects.create(
account=self.auth.get_account(),
title=params.str('title', desc='标题'),
content=params.str('content', desc='正文'),
show=params.bool('show', desc='是否展示', default=True, require=False)
)
# 关联资源元数据
if params.has('resources'):
meta_list = {ResourceLogic.decode_token(token) for token in params.list('resources', desc='资源信息')}
try:
meta_list.remove(None)
except:
pass
exhibition.resource.set(list(meta_list))
exhibition.save()
return SuccessResult(id=exhibition.id)
def get(self, request):
"""
获取tag列表
:param request:
:return:
"""
data = self.get_data()
return SuccessResult(data)