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):
"""
注册账户 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 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, sid, aid):
"""
获取报名表模板列表
:param request:
:param sid:
:param aid:
:return:
"""
logic = TemplateLogic(self.auth, sid, aid)
params = ParamsParser(request.GET)
limit = params.int('limit', desc='每页最大渲染数', require=False, default=10)
page = params.int('page', desc='当前页数', require=False, default=1)
templates = InterviewRegistrationTemplate.objects.values('id', 'update_time').filter(
association=logic.association)
if params.has('key'):
key = params.str('key', desc='关键字 标题 创建人昵称')
templates = templates.filter(
Q(title__contains=key) |
Q(author__nickname__contains=key)
)
templates, pagination = slicer(templates, limit=limit, page=page)()()
return Result(templates=templates, pagination=pagination, association_id=self.auth.get_association_id())
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 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 get(self, request, sid, aid):
"""
获取协会部门列表
:param request:
:param sid:
:param aid:
:return:
"""
# 自动权限检查
logic = AssociationLogic(self.auth, sid, aid)
params = ParamsParser(request.GET)
limit = params.int('limit', desc='每页最大渲染数', require=False, default=10)
page = params.int('page', desc='当前页数', require=False, default=1)
department = AssociationDepartment.objects.values(
'id', 'update_time').filter(association__id=aid)
if params.has('key'):
key = params.str('key', desc='关键字 名称 缩写')
department = department.filter(
Q(name__contains=key) | Q(short_name__contains=key))
@slicer(department, limit=limit, page=page)
def get_department_list(obj):
return obj
departments, pagination = get_department_list()
return Result(departments=departments,
pagination=pagination,
association_id=self.auth.get_association_id())
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, 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: -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, 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 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, 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 put(self, request, aid=''):
"""
修改用户自身信息 or 管理员修改用户信息
:param request:
:param aid:
:return:
"""
params = ParamsParser(request.JSON)
is_admin = False
if self.auth.get_account().role == int(RoleEnum.ADMIN):
alogic = AccountLogic(self.auth, aid)
account = alogic.account
is_admin = True
else:
account = self.auth.get_account()
with params.diff(account):
account.nickname = params.str('nickname', desc='昵称')
account.realname = params.str('realname', desc='真实名称')
account.sex = params.int('sex', desc='性别')
account.email = params.str('email', desc='邮箱')
account.phone = params.str('phone', desc='电话号码')
account.motto = params.str('motto', desc='一句话留言')
if is_admin and params.has('permission'):
account.permissions = json.dumps(
params.dict('permissions', desc='权限'))
account.save()
return Result(id=account.id,
association_id=self.auth.get_association_id())
def get(self, request, sid, aid):
"""
获取协会用户列表
:param request:
:param sid:
:param aid:
:return:
"""
# 自动权限检查
logic = AssociationLogic(self.auth, sid, aid)
params = ParamsParser(request.GET)
limit = params.int('limit', desc='每页最大渲染数', require=False, default=10)
page = params.int('page', desc='当前页数', require=False, default=1)
accounts = AssociationAccount.objects.values(
'id', 'update_time').filter(association__id=aid)
if params.has('key'):
accounts = accounts.filter(
nickname__contains=params.str('key', desc='关键字'))
if params.has('role'):
accounts = accounts.filter(role=params.int('role', desc='身份'))
if params.has('retire'):
accounts = accounts.filter(
retire=params.bool('retire', desc='退休与否'))
if params.has('department'):
accounts = accounts.filter(
department__id=params.int('department', desc='部门id'))
accounts, pagination = slicer(accounts, limit=limit, page=page)()()
return Result(accounts=accounts,
pagination=pagination,
association_id=self.auth.get_association_id())
def get(self, request):
"""
获取学校列表
:return:
"""
params = ParamsParser(request.GET)
limit = params.int('limit', desc='每页最大渲染数', require=False, default=10)
page = params.int('page', desc='当前页数', require=False, default=1)
schools = School.objects.values(
'id', 'update_time').all()
if params.has('key'):
key = params.str('key', desc='关键字 名称 缩写')
schools = schools.filter(
Q(name__contains=key) |
Q(short_name__contains=key)
)
@slicer(
schools,
limit=limit,
page=page
)
def get_school_list(obj):
return obj
schools, pagination = get_school_list()
return Result(schools=schools, pagination=pagination, association_id=self.auth.get_association_id())
def get(self, request, sid, aid):
"""
获取评分表列表
:param request:
:param sid:
:param aid:
:return:
"""
logic = AppraisingLogic(self.auth, sid, aid)
# logic.check(AssociationPermissionEnum.APPRAISING)
params = ParamsParser(request.GET)
limit = params.int('limit', desc='每页最大渲染数', require=False, default=10)
page = params.int('page', desc='当前页数', require=False, default=1)
template = AppraisingScoreTemplate.objects.values(
'id', 'update_time').filter(association=logic.association)
if params.has('title'):
template = template.filter(
title__contains=params.str('title', desc='标题'))
templates, pagination = slicer(template, limit=limit, page=page)()()
return Result(templates=templates,
pagination=pagination,
association_id=self.auth.get_association_id())
def get(self, request, sid, aid):
"""
查询协会无课表配置 或 重置无课表信息
:param request:
:param sid:
:param aid:
:return:
"""
logic = CurriculumLogic(self.auth, sid, aid)
if self.RESET:
# logic.check(AssociationPermissionEnum.SCHEDULING)
logic.curriculum.content = logic.get_school_curriculum_config().dumps()
logic.curriculum.save()
return Result(association_id=self.auth.get_association_id())
# 权限
return Result(data=logic.get_curriculum_info(), association_id=self.auth.get_association_id())
def get(self, request, sid):
"""
获取学校信息
:param request:
:param sid:
:return:
"""
logic = SchoolLogic(self.auth, sid)
return Result(data=logic.get_school_info(), association_id=self.auth.get_association_id())
def get(self, request, sid, aid):
"""
获取协会信息 or 获取评优版本信息
:param request:
:param sid:
:param aid:
:return:
"""
logic = AssociationLogic(self.auth, sid)
logic.association = logic.get_association(aid)
# 获取评优版本信息
if self.VERSION:
check_login(lambda x: True)(self)
# 敏感数据权限 部长以上即放行
# logic.check(AssociationPermissionEnum.ASSOCIATION_VIEW_DATA)
return Result(data=logic.get_config().version_dict, association_id=self.auth.get_association_id())
logic.account = logic.get_association_account(throw=True)
return Result(data=logic.get_association_info(), association_id=self.auth.get_association_id())
def get(self, request, aid=''):
"""
提权（创建协会权限）or 获取用户列表
:param request:
:param aid:
:return:
"""
if not self.LIST:
alogic = AccountLogic(self.auth, aid)
permissions = AccountPermissionEntity.parse(
alogic.account.permissions)
permissions.create = True
alogic.account.permissions = permissions.dumps()
alogic.account.save()
return Result(id=alogic.account.id,
association_id=self.auth.get_association_id())
params = ParamsParser(request.GET)
limit = params.int('limit', desc='每页最大渲染数', require=False, default=10)
page = params.int('page', desc='当前页数', require=False, default=1)
accounts = Account.objects.values('id', 'update_time').all()
if params.has('key'):
key = params.str('key', desc='关键字 email 昵称 真实姓名 联系电话')
accounts = accounts.filter(
Q(email__contains=key) | Q(nickname__contains=key)
| Q(realname__contains=key) | Q(phone__contains=key))
if params.has('role'):
accounts = accounts.filter(role=params.int('role', desc='身份角色'))
@slicer(accounts, limit=limit, page=page)
def get_account_list(obj):
return obj
accounts, pagination = get_account_list()
return Result(accounts=accounts,
pagination=pagination,
association_id=self.auth.get_association_id())
def get(self, request, sid, aid):
"""
汇总无课表 or 获取课表信息
:param request:
:param sid:
:param aid:
:return: redis key scheduling:协会id:
"""
redis = SchedulingRedis()
logic = CurriculumLogic(self.auth, sid, aid)
# 获取课表信息
if not self.SUMMARY:
return Result(data=logic.get_account_curriculum_info(), association_id=self.auth.get_association_id())
# 汇总无课表 不包括退休人员
# logic.check(AssociationPermissionEnum.SCHEDULING)
_id = str(logic.association.id)
if redis.exists(_id):
data = redis.get_json(_id)
else:
curriculums = AssociationAccountCurriculum.objects.filter_cache(curriculum=logic.curriculum, account__retire=False)
account_ids = AssociationAccount.objects.values('id').filter(association=logic.association, retire=False)
config = logic.get_association_curriculum_config()
keys = config.time().keys()
data = {"day{}".format(i): {k:[] for k in keys} for i in range(1, 8)}
# 构建无课表
for curriculum in curriculums:
# 获取该账户信息
content = json.loads(curriculum.content)
nickname = curriculum.account.nickname
# 填充账户无课表信息
for index, _time in content.items():
for k, v in _time.items():
if not v:
data[index][k].append(nickname)
data['completion'] = account_ids.count() / len(curriculums)
redis.set(_id, data)
return Result(data=data, association_id=self.auth.get_association_id())
def get(self, request, sid, aid, tid):
"""
获取任务表
:param request:
:param sid:
:param aid:
:param tid:
:return:
"""
logic = TaskLogic(self.auth, sid, aid, tid)
return Result(data=logic.get_task_info(), association_id=self.auth.get_association_id())
def get(self, request, sid, aid, rtid):
"""
获取报名表模板信息
:param request:
:param sid:
:param aid:
:param rtid:
:return:
"""
logic = TemplateLogic(self.auth, sid, aid, rtid)
return Result(data=logic.get_template_info(), association_id=self.auth.get_association_id())
def delete(self, request, sid, aid):
"""
删除协会 仅系统管理员有权限删除协会
:param request:
:param sid:
:param aid:
:return:
"""
alogic = AssociationLogic(self.auth, sid, aid)
alogic.association.delete()
return Result(id=aid, association_id=self.auth.get_association_id())
def get(self, request, sid, aid=""):
"""
重置协会码 or 获取协会列表
:param request:
:param sid:
:param aid:
:return:
"""
# 重置协会码
if not self.LIST:
check_login(lambda x: True)(self)
logic = AssociationLogic(self.auth, sid, aid)
# logic.check(AssociationPermissionEnum.ASSOCIATION_VIEW_DATA)
logic.association.choosing_code = AssociationLogic.elective_code()
logic.association.save()
return Result(id=aid)
# 获取协会列表
params = ParamsParser(request.GET)
limit = params.int('limit', desc='每页最大渲染数', require=False, default=10)
page = params.int('page', desc='当前页数', require=False, default=1)
associations = Association.objects.values('id', 'update_time').filter(school__id=sid)
if params.has('key'):
key = params.str('key', desc='关键字 名称 缩写')
try:
key = int(key)
associations = associations.filter(
Q(name__contains=key) |
Q(short_name__contains=key) |
Q(id=key)
)
except:
associations = associations.filter(
Q(name__contains=key) |
Q(short_name__contains=key)
)
associations, pagination = slicer(associations, limit=limit, page=page)()()
return Result(associations=associations, pagination=pagination, association_id=self.auth.get_association_id())
def get(self, request, sid, aid, psid):
"""
获取评分表信息
:param request:
:param sid:
:param aid:
:param psid:
:return:
"""
logic = AppraisingScoreLogic(self.auth, sid, aid, psid)
# logic.check(AssociationPermissionEnum.APPRAISING, AssociationPermissionEnum.ASSOCIATION_VIEW_DATA)
return Result(data=logic.get_score_info(), association_id=self.auth.get_association_id())
