def put(self, request, sid, aid, vid):
"""
修改考勤记录
:param request:
:param sid:
:param aid:
:param vid:
:return:
"""
logic = AttendanceLogic(self.auth, sid, aid, vid)
# logic.check(AssociationPermissionEnum.ATTENDANCE)
params = ParamsParser(request.JSON)
attendance = logic.attendance
# 过滤标题
if params.has('title'):
title = params.str('title', desc='标题')
if AssociationAttendance.objects.filter(
title=title, association=logic.association).exclude(
id=attendance.id).exists():
raise AttendanceExcept.title_exist()
attendance.title = title
with params.diff(attendance):
attendance.description = params.str('description', desc='描述')
attendance.place_x = params.float('place_x', desc='考勤纬度')
attendance.place_y = params.float('place_y', desc='考勤经度')
attendance.distance = params.float('distance', desc='容错距离')
attendance.start_time = params.float('start_time', desc='开始时间')
attendance.end_time = params.float('end_time', desc='结束时间')
attendance.save()
return Result(id=vid, association_id=self.auth.get_association_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, aid, vid):
"""
发起请假
:param request:
:param sid:
:param aid:
:param vid:
:return:
"""
params = ParamsParser(request.JSON)
alogic = AttendanceLogic(self.auth, sid, aid, vid)
# if alogic.attendance.end_time < time.time():
# raise AttendanceExcept.no_in_place()
# 获取协会待办事项
description = params.str('description', desc='请假事由')
backlog = AssociationBacklog.parse(alogic.association.backlog)
# key: [人事id][考勤表id] = 请假事由
_attendance = backlog.attendance()
if str(vid) in _attendance:
if str(alogic.account.id) in _attendance[str(vid)]["data"]:
_attendance[str(vid)]["data"][str(
alogic.account.id)]["description"] = description
else:
_attendance[str(vid)]["data"][str(alogic.account.id)] = {
"name": alogic.account.nickname,
"description": description
}
else:
_attendance[str(vid)] = {
"name": alogic.attendance.title,
"data": {
str(alogic.account.id): {
"name": alogic.account.nickname,
"description": description
}
}
}
"""
{
attendance: {
"考勤id": {
"name": "考勤名字",
"data": {
"人id": {
"name": "名字",
"description": "请假事由"
}
}
}
}
}
"""
backlog.attendance = _attendance
# 更新数据库
alogic.association.backlog = backlog.dumps()
alogic.association.save()
return Result(id=vid, association_id=self.auth.get_association_id())
def post(self, request, sid, aid, vid):
"""
获取考勤情况
:param request:
:param sid:
:param aid:
:param vid:
:return:
"""
logic = AttendanceLogic(self.auth, sid, aid, vid)
params = ParamsParser(request.JSON)
_type = params.int('type', desc='考勤类别', default=0,
require=False) # type: int 0-协会 1-部门 2-个人
data = {}
if _type == 2:
data = logic.get_account_sign_info()
else:
# logic.check(AssociationPermissionEnum.ATTENDANCE)
if _type == 0:
data = logic.get_association_sign_info()
elif _type == 1:
data = logic.get_department_sign_info(
params.int('department', desc='部门id'))
return Result(data=data, association_id=self.auth.get_association_id())
def post(self, request, sid, aid):
"""
批量获取协会考勤信息
:param request:
:param sid:
:param aid:
:return: -1-尚未开始 0-已经结束 1-正在进行
"""
redis = AttendanceRedisFactory()
params = ParamsParser(request.JSON)
logic = AttendanceLogic(self.auth, sid, aid)
ids = params.list('ids', desc='考勤表id')
data = list()
attendances = AssociationAttendance.objects.get_many(ids=ids)
_deparment_id = "-1" if logic.account.department is None else logic.account.department_id
_aid = logic.account.id
for attendance in attendances:
logic.attendance = attendance
try:
info = logic.get_attendance_info()
_status = redis.hget(
logic.build_key(logic.attendance.id, _deparment_id), _aid)
if _status is None:
_status = -1
info["attendance_status"] = _status
data.append(info)
except:
pass
return Result(data=data, association_id=self.auth.get_association_id())
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 post(self, request, sid, aid):
"""
批量记住通知
:param request:
:param sid:
:param aid:
:return:
"""
logic = NoticeLogic(self.auth, sid, aid)
params = ParamsParser(request.JSON)
ids = params.list("ids", desc="通知id列表")
static = {}
notices = AssociationNotice.objects.get_many(ids=ids)
for notice in notices:
logic.notice = notice
if logic.notice.association_id != logic.association.id:
_static = -1
else:
_static = 1 if logic.remember() else 0
static[str(notice.id)] = _static
return Result(static=static)
def post(self, request, sid, aid):
"""
提交评分表
:param request:
:param sid:
:param aid:
:return:
"""
logic = AppraisingScoreLogic(self.auth, sid, aid)
# logic.check(AssociationPermissionEnum.APPRAISING, AssociationPermissionEnum.ASSOCIATION_VIEW_DATA)
params = ParamsParser(request.JSON)
target_id = params.int('target_id', desc='填写对象id')
content = params.dict('content', desc='评分正文') # type: dict {"number": "answer"}
# 检查目标用户是否符合标准
if not AssociationAccount.objects.filter(association=logic.association, id=target_id).exists():
raise AssociationExcept.not_account()
# 过滤非发起评优时段提交 或 已填写过
if AppraisingScore.objects.filter(target_id=target_id, association=logic.association).exists():
raise AppraisingInfoExcept.no_time_post()
score = AppraisingScore.objects.create(
author=logic.account,
association=logic.association,
target_id=target_id,
content=json.dumps(content),
version=logic.get_version(),
score=logic.content_to_score(content),
template_id=logic.get_template_id(),
)
return Result(id=score.id, association_id=self.auth.get_association_id())
def get(self, request, sid, aid):
"""
发起招新
:param request:
:param sid:
:param aid:
:return:
"""
logic = RegistrationLogic(self.auth, sid, aid)
# logic.check(AssociationPermissionEnum.INTERVIEW)
params = ParamsParser(request.GET)
template_id = params.int('template_id', desc='使用模板id')
start_time = params.float('start_time', desc='开始时间')
end_time = params.float('end_time', desc='结束时间')
# 更新协会配置
config = AssociationConfigureEntity.parse(logic.association.config)
interview_version_dict = config.interview_version_dict()
interview_version_dict[str(config.interview_version() + 1)] = {
"template_id": template_id,
"start_time": start_time,
"end_time": end_time
}
config.interview_version = logic.get_interview_version() + 1
config.interview_version_dict = interview_version_dict
logic.association.config = config.dumps()
logic.association.save()
return Result(association_id=self.auth.get_association_id(),
status="success")
def post(self, request):
"""
开发登陆接口
:param request:
:return:
"""
params = ParamsParser(request.JSON)
code = params.str('token', desc='验证ID')
accounts = Account.objects.filter(temp_access_token=code)
if not accounts.exists():
try:
account = Account.objects.create(
temp_access_token=code,
role=int(RoleEnum.DIRECTOR),
permissions=AccountPermissionEntity().dumps(),
)
except:
raise AccountInfoExcept.account_filter_error()
else:
account = accounts[0]
self.auth.set_account(account)
if self.WEB:
self.auth.set_session()
return Result(id=account.id)
return Result(data={
"id": account.id,
"token": self.auth.create_token()
},
association_id=self.auth.get_association_id())
def post(self, request, sid, aid):
"""
加入协会
:param request:
:param sid:
:param aid:
:return:
"""
logic = AssociationLogic(self.auth, sid)
logic.association = logic.get_association(aid)
account = self.auth.get_account()
params = ParamsParser(request.JSON)
choosing_code = params.str('choosing_code')
if logic.association.choosing_code != choosing_code:
_status = -1
else:
# 判断是否已加入该协会
_account = AssociationAccount.objects.filter(
association=logic.association,
account=account,
)
if _account.exists():
_status = 1
else:
ata = AssociationAccount.objects.create(
nickname=account.nickname,
association=logic.association,
account=account,
)
_status = 0
return Result(status=_status,
association_id=self.auth.get_association_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)
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 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 get(self, request, sid, aid):
"""
获取考勤列表
:param request:
:param sid:
: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)
logic = AssociationLogic(self.auth, sid, aid)
attendances = AssociationAttendance.objects.values(
'id', 'update_time').filter(association__id=aid).filter(
Q(department__isnull=True)
| Q(department=logic.account.department))
if params.has('title'):
attendances = attendances.filter(
title__contains=params.str('title', desc='标题'))
if params.has('start_time'):
attendances = attendances.filter(
start_time__gte=params.float('start_time', desc='开始时间'))
if params.has('end_time'):
attendances = attendances.filter(
end_time__lte=params.float('end_time', desc='结束时间'))
@slicer(attendances, limit=limit, page=page)
def get_attendances_list(obj):
return obj
attendances, pagination = get_attendances_list()
return Result(attendances=attendances,
pagination=pagination,
association_id=self.auth.get_association_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 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 post(self, request, sid, aid):
"""
批量获通知信息
:param request:
:param sid:
:param aid:
:return:
"""
params = ParamsParser(request.JSON)
logic = NoticeLogic(self.auth, sid, aid)
ids = params.list('ids', desc='通知id列表')
notices = AssociationNotice.objects.get_many(ids=ids)
data = list()
for notice in notices:
try:
logic.notice = notice
if logic.notice.association_id != logic.association.id:
continue
data.append(logic.get_notice_info())
except:
pass
return Result(data=data, association_id=self.auth.get_association_id())
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 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 post(self, request):
"""
注册账户 or 登陆账户
:param request:
:return:
"""
params = ParamsParser(request.JSON)
code = params.str('token', desc='验证ID')
openid, session = self.get_openid(code)
client_auth_mode = self.request.META.get(
'HTTP_HOHO_AUTH_MODEL') == "client"
accounts = Account.objects.filter_cache(temp_access_token=openid)
if len(accounts) == 0:
nickname = params.str('nickname', desc='昵称')
sex = params.int('sex', desc='性别')
try:
account = Account.objects.create(
realname=nickname,
nickname=nickname,
sex=sex,
temp_access_token=openid,
role=int(RoleEnum.DIRECTOR),
permissions=AccountPermissionEntity().dumps(),
motto="这个人很懒，什么jb都没有")
_id = account.id
except:
fake = Faker(locale='zh_CN')
p = fake.profile()
nickname = p.get('name', "****")
account = Account.objects.create(
realname=nickname,
nickname=nickname,
sex=sex,
temp_access_token=openid,
role=int(RoleEnum.DIRECTOR),
permissions=AccountPermissionEntity().dumps(),
motto="这个人很懒，什么jb都没有")
_id = account.id
else:
account = accounts[0]
_id = account.id
# 更新数据
self.auth.set_account(account)
# 载入登陆信息
if client_auth_mode:
return Result(data={
"id": _id,
"token": self.auth.create_token()
},
association_id=self.auth.get_association_id())
self.auth.set_account(account)
self.auth.set_session()
return Result(id=_id)
def post(self, request, sid):
"""
创建协会
:param request:
:param sid:
:return:
"""
logic = AssociationLogic(self.auth, sid)
params = ParamsParser(request.JSON)
account = self.auth.get_account()
# 权限检查
# permission_entity = AccountPermissionEntity.parse(self.auth.get_account().permissions)
# if not permission_entity.create():
# raise AssociationExcept.no_permission()
# 创建协会
name = params.str('name', desc='名称')
if Association.objects.values('id').filter(school__id=sid, name=name).exists():
return Result(status=-1, association_id=self.auth.get_association_id())
config = AssociationConfigureEntity()
association = Association.objects.create(
name=name,
short_name=params.str('short_name', desc='缩写', require=False, default=''),
description=params.str('description', desc='简介', require=False, default=''),
choosing_code=AssociationLogic.elective_code(),
config=config.dumps(),
school=logic.school,
)
# 创建课表配置
AssociationCurriculum.objects.create(
title="{}课表配置".format(association.name),
association=association,
content=logic.get_school_curriculum_config().dumps()
)
# 创建协会人事关联
AssociationAccount.objects.create(
nickname=account.realname,
account=account,
association=association,
role=int(RoleEnum.PRESIDENT),
)
# 非系统管理员只拥有一次性创建协会权限
if self.auth.get_account().role != int(RoleEnum.ADMIN):
account = self.auth.get_account()
permissions = AccountPermissionEntity.parse(account.permissions)
permissions.create = False
account.permissions = permissions.dumps()
account.save()
return Result(status=1, association_id=self.auth.get_association_id())
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 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 post(self, request):
"""
开发登陆接口
:param request:
:return:
"""
params = ParamsParser(request.JSON)
token = params.str('token', desc='token')
accounts = FaceUAccount.objects.filter_cache(temp_access_token=token)
self.auth.set_account(accounts[0])
self.auth.set_session()
return SuccessResult(id=accounts[0].id)
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 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, aid):
"""
获取报名表列表
:param request:
:param sid:
:param aid:
:return:
"""
logic = AssociationLogic(self.auth, sid, aid)
# logic.check(AssociationPermissionEnum.INTERVIEW)
params = ParamsParser(request.GET)
limit = params.int('limit', desc='每页最大渲染数', require=False, default=10)
page = params.int('page', desc='当前页数', require=False, default=1)
registrations = InterviewRegistration.objects.values(
'id', 'update_time').filter(association=logic.association)
if params.has('version'):
registrations = registrations.filter(
version=params.int('version', desc='版本号'))
if params.has('key'):
key = params.str('key', desc='关键字 报名用户昵称 真实名称')
registrations = registrations.filter(
Q(account__nickname__contains=key)
| Q(account__realname__contains=key))
registrations, pagination = slicer(registrations,
limit=limit,
page=page)()()
return Result(registrations=registrations,
pagination=pagination,
association_id=self.auth.get_association_id())
def get(self, request):
"""
切换学校id
:param request:
:return:
"""
params = ParamsParser(request.GET)
code = params.int('school_id', desc='协会id')
try:
self.auth.update_school_id(code)
except:
raise AccountInfoExcept.error()
return Result(id=code, association_id=code)
