def api_new_expert(request, para):
try:
subjudge = SubJudge.objects.filter(id=int(para.subjudge_id)).first()
if not subjudge:
raise BusinessException(ERR_SUBJUDGE_NOT_EXIST)
user, role = get_user(subjudge.activity, request.user)
if not user:
raise BusinessException(ERR_USER_AUTH)
# 仅子级评审的维护者可使用
if not subjudge_services.is_subjudge_manager(subjudge, request.user):
raise BusinessException(ERR_USER_AUTH)
area = Area.objects.filter(del_flag=FLAG_NO, id=int(
para.area_id)).first() if para.area_id else None
direct_area = Area.objects.filter(
del_flag=FLAG_NO, id=int(
para.direct_area_id)).first() if para.direct_area_id else None
result = subjudge_services.new_expert(request.user, subjudge, user,
para.mobile, para.name, para.sex,
area, direct_area,
para.institution, para.position)
except Exception as ex:
logger.exception(ex)
return response_exception(ex)
return response200(dict(c=SUCCESS[0], m=SUCCESS[1], d=result))
def api_download_activity_role_template(request, para):
try:
activity = Activity.objects.filter(id=int(para.activity_id)).first()
if not activity:
raise BusinessException(ERR_ACTIVITY_NOT_EXIST)
user, role = get_user(activity, request.user)
if not user:
raise BusinessException(ERR_USER_AUTH)
wb = activity_s.download_activity_role_template(
request.user, activity, user, role)
fname = u'%s.xlsx' % suuid()
response = HttpResponse(content_type='application/vnd.ms-excel')
response[
'Content-Disposition'] = 'attachment; filename=' + fname.encode(
'utf-8')
wb.save(response)
return response
# path = os.path.join(settings.BASE_DIR, 'media/%s.xlsx' % suuid())
# wb.save(path)
# return response200({'c': SUCCESS[0], 'm': SUCCESS[1], 'd': path})
except Exception as ex:
logger.exception(ex)
return response_exception(ex, ex.message)
def api_export_team(request, para):
try:
subjudge = SubJudge.objects.filter(id=int(para.subjudge_id)).first()
if not subjudge:
raise BusinessException(ERR_SUBJUDGE_NOT_EXIST)
user, role = get_user(subjudge.activity, request.user)
if not user:
raise BusinessException(ERR_USER_AUTH)
# 仅子级评审的维护者可使用
if not subjudge_services.is_subjudge_manager(subjudge, request.user):
raise BusinessException(ERR_USER_AUTH)
subjudge_team_id_list = [
int(each)
for each in para.subjudge_team_list.strip().strip(',').split(',')
if each
]
# team_list = list(Team.objects.filter(id__in=team_id_list))
wb = subjudge_services.export_team(request.user, subjudge, user, role,
subjudge_team_id_list)
fname = u'%s.xlsx' % suuid()
response = HttpResponse(content_type='application/vnd.ms-excel')
response[
'Content-Disposition'] = 'attachment; filename=' + fname.encode(
'utf-8')
wb.save(response)
return response
# path = os.path.join(settings.BASE_DIR, 'media/%s.xlsx' % suuid())
# wb.save(path)
# return response200({'c': SUCCESS[0], 'm': SUCCESS[1], 'd': path})
except Exception as ex:
logger.exception(ex)
return response_exception(ex)
def api_export_activity_expert(request, para):
try:
activity = Activity.objects.filter(id=int(para.activity_id)).first()
if not activity:
raise BusinessException(ERR_ACTIVITY_NOT_EXIST)
user, role = get_user(activity, request.user)
if not user:
raise BusinessException(ERR_USER_AUTH)
expert_id_list = [
int(r) for r in para.expert_id_list.strip().strip(',').split(',')
]
expert_list = Expert.objects.filter(del_flag=FALSE_INT,
id__in=expert_id_list)
wb = activity_s.export_activity_expert(request.user, activity, user,
role, expert_list)
fname = u'%s.xlsx' % suuid()
response = HttpResponse(content_type='application/vnd.ms-excel')
response[
'Content-Disposition'] = 'attachment; filename=' + fname.encode(
'utf-8')
wb.save(response)
return response
# path = os.path.join(settings.BASE_DIR, 'media/%s.xlsx' % suuid())
# wb.save(path)
# return response200({'c': SUCCESS[0], 'm': SUCCESS[1], 'd': path})
except Exception as ex:
logger.exception(ex)
return response_exception(ex, ex.message)
def api_import_activity_expert(request, para):
try:
activity = Activity.objects.filter(id=int(para.activity_id)).first()
if not activity:
raise BusinessException(ERR_ACTIVITY_NOT_EXIST)
user, role = get_user(activity, request.user)
if not user:
raise BusinessException(ERR_USER_AUTH)
result = activity_s.import_activity_expert(request.user, user, role,
activity, para.file)
except Exception as ex:
logger.exception(ex)
return response_exception(ex, ex.message)
return response200(dict(c=SUCCESS[0], m=SUCCESS[1], d=result))
def api_available_add_activity_expert(request, para):
try:
activity = Activity.objects.filter(id=int(para.activity_id)).first()
if not activity:
raise BusinessException(ERR_ACTIVITY_NOT_EXIST)
user, role = get_user(activity, request.user)
if not user:
raise BusinessException(ERR_USER_AUTH)
result = activity_s.available_add_activity_expert(
request.user, activity, user, para.keyword, para.rows, para.page)
except Exception as ex:
logger.exception(ex)
return response_exception(ex)
return response200(result)
def api_update_expert_in_team(request, para):
try:
team = Team.objects.filter(id=int(para.team_id)).first()
if not team:
raise BusinessException(ERR_TEAM_NOT_EXIST)
user, role = get_user(team.activity, request.user)
if not user:
raise BusinessException(ERR_USER_AUTH)
result = t_services.update_expert_in_team(request.user, user, role,
team, para.new_expert_json)
except Exception as ex:
logger.exception(ex)
return response_exception(ex, ex.message)
return response200({'c': SUCCESS[0], 'm': SUCCESS[1], 'd': result})
def api_detail_activity_role(request, para):
try:
role_retrieved = Role.objects.filter(id=int(para.role_id)).first()
if not role_retrieved:
raise BusinessException(ERR_USER_NOT_EXIST)
user, role = get_user(role_retrieved.activity, request.user)
if (not user) or (not role):
raise BusinessException(ERR_USER_AUTH)
result = activity_s.detail_activity_role(role_retrieved.activity, user,
role, role_retrieved)
except Exception as e:
logger.exception(e)
return response_exception(e)
return response200({'c': SUCCESS[0], 'm': SUCCESS[1], 'd': result})
def api_add_activity_role_registered(request, para):
activity = Activity.objects.filter(id=int(para.activity_id)).first()
if not activity:
raise BusinessException(ERR_ACTIVITY_NOT_EXIST)
user, role = get_user(activity, request.user)
if not user:
raise BusinessException(ERR_USER_AUTH)
try:
account_id_list = para.account_id_list.strip().strip(',').split(',')
result = activity_s.add_activity_role_registered(
request.user, activity, user, account_id_list)
except Exception as ex:
logger.exception(ex)
return response_exception(ex, ex.message)
return response200(result)
def api_list_team_by_super(request, para):
try:
activity = Activity.objects.filter(id=int(para.activity_id)).first()
if not activity:
raise BusinessException(ERR_ACTIVITY_NOT_EXIST)
user, role = get_user(activity, request.user)
if not user:
raise BusinessException(ERR_USER_AUTH)
result = t_services.list_team_by_super(request.user, activity,
para.keyword, para.judger,
para.page, para.rows)
except Exception as ex:
logger.exception(ex)
return response_exception(ex, ex.message)
return response200({'c': SUCCESS[0], 'm': SUCCESS[1], 'd': result})
def api_remove_activity_role(request, para):
try:
activity = Activity.objects.filter(id=int(para.activity_id)).first()
if not activity:
raise BusinessException(ERR_ACTIVITY_NOT_EXIST)
user, role = get_user(activity, request.user)
if not user:
raise BusinessException(ERR_USER_AUTH)
result = activity_s.remove_activity_role(
request.user, activity, role,
[int(r) for r in para.role_id_list.strip().strip(',').split(',')])
except Exception as ex:
logger.exception(ex)
return response_exception(ex, ex.message)
return response200(result)
def api_available_registered_add_role(request, para):
try:
activity = Activity.objects.filter(id=int(para.activity_id)).first()
if not activity:
raise BusinessException(ERR_ACTIVITY_NOT_EXIST)
user, role = get_user(activity, request.user)
if not user:
raise BusinessException(ERR_USER_AUTH)
result = activity_s.available_registered_add_role(
request.user, user, role, activity, para.keyword, para.page,
para.rows)
except Exception as ex:
logger.exception(ex)
return response_exception(ex, ex.message)
return response200({'c': SUCCESS[0], 'm': SUCCESS[1], 'd': result})
def api_area_stats_team_expert(request, para):
# 该子级评审专家组中各个专家都来自于哪一个地区
try:
subjudge_team = SubJudgeTeam.objects.filter(
id=int(para.subjudge_team)).first()
if not subjudge_team:
raise BusinessException(ERR_SUBJUDGE_TEAM_NOT_EXIST)
user, role = get_user(subjudge_team.subjudge.activity, request.user)
if not user:
raise BusinessException(ERR_USER_AUTH)
result = subjudge_services.area_stats_team_expert(
subjudge_team, user, role)
except Exception as e:
logger.exception(e)
return response_exception(e)
return response200({'c': SUCCESS[0], 'm': SUCCESS[1], 'd': result})
def api_import_expert(request, para):
try:
subjudge = SubJudge.objects.filter(id=int(para.subjudge_id)).first()
if not subjudge:
raise BusinessException(ERR_SUBJUDGE_NOT_EXIST)
user, role = get_user(subjudge.activity, request.user)
if not user:
raise BusinessException(ERR_USER_AUTH)
# 仅子级评审的维护者可使用
if not subjudge_services.is_subjudge_manager(subjudge, request.user):
raise BusinessException(ERR_USER_AUTH)
result = subjudge_services.import_expert(request.user, user, role,
subjudge, para.file)
except Exception as ex:
logger.exception(ex)
return response_exception(ex, ex.message)
return response200(dict(c=SUCCESS[0], m=SUCCESS[1], d=result))
def api_delete_activity_expert(request, para):
try:
activity = Activity.objects.get(pk=int(para.activity_id))
if not activity:
raise BusinessException(ERR_ACTIVITY_NOT_EXIST)
user, role = get_user(activity, request.user)
if not user:
raise BusinessException(ERR_USER_AUTH)
result = activity_s.remove_activity_expert(
request.user, activity, user, [
int(e)
for e in para.expert_id_list.strip().strip(',').split(',')
])
except Exception as ex:
logger.exception(ex)
return response_exception(ex, ex.message)
log_response(request, result)
return response200(result)
def work_availale_add_team(account, subjudge, subjudge_team, sub_activity,
phase, project, area, direct_area, subject, keyword,
ignore_area_list, page, rows):
my_user, role = get_user(subjudge.activity, account)
# 该级别管理员可见的作品
all, non_approved = works_manager_can_see(my_user, subjudge.activity,
sub_activity, phase, project,
area, direct_area, subject,
keyword)
# 哪些作品可以加入分组（两种可能的规则：所有可见作品均可，仅未审核的可加入）
handle = all
subjg_t_w_work = [each.work for each in SubJudgeTeamWork.objects.all()]
final_handle = filter(lambda x: x['work'] not in subjg_t_w_work, handle)
paged_data, result = paging_by_page(final_handle, rows, page)
for each in paged_data:
result['items'].append(struct_work(each['work'], my_user.area))
return result
def api_decide_subjudge(request, para):
try:
activity = Activity.objects.filter(id=int(para.activity_id)).first()
if not activity:
raise BusinessException(ERR_ACTIVITY_NOT_EXIST)
user, role = get_user(activity, request.user)
if not user:
raise BusinessException(ERR_USER_AUTH)
result = subjudge_services.decide_subjudge(
request.user,
user,
role,
activity,
para.is_active,
para.data,
)
except Exception as e:
logger.exception(e)
return response_exception(e)
return response200({'c': SUCCESS[0], 'm': SUCCESS[1], 'd': result})
def api_add_activity_expert_new(request, para):
try:
activity = Activity.objects.filter(id=int(para.activity_id)).first()
if not activity:
raise BusinessException(ERR_ACTIVITY_NOT_EXIST)
user, role = get_user(activity, request.user)
if not user:
raise BusinessException(ERR_USER_AUTH)
area = Area.objects.filter(del_flag=FLAG_NO, id=int(
para.area_id)).first() if para.area_id else None
direct_area = Area.objects.filter(
del_flag=FLAG_NO, id=int(
para.direct_area_id)).first() if para.direct_area_id else None
result = activity_s.add_activity_expert_new(
request.user, activity, user, para.mobile, para.name, para.sex,
area, direct_area, para.institution, para.position)
except Exception as ex:
logger.exception(ex)
return response_exception(ex)
return response200(dict(c=SUCCESS[0], m=SUCCESS[1], d=result))
def api_add_activity_role_new(request, para):
try:
activity = Activity.objects.filter(id=int(para.activity_id)).first()
if not activity:
raise BusinessException(ERR_ACTIVITY_NOT_EXIST)
area = Area.objects.filter(
id=int(para.area_id)).first() if para.area_id else None
direct_area = Area.objects.filter(id=int(
para.direct_area_id)).first() if para.direct_area_id else None
user, role = get_user(activity, request.user)
if not user:
raise BusinessException(ERR_USER_AUTH)
result = activity_s.add_activity_role_new(request.user, activity, user,
para.mobile, para.name,
para.sex, area, direct_area,
para.institution,
para.max_work)
except Exception as ex:
logger.exception(ex)
return response_exception(ex, ex.message)
return response200(result)
def api_list_activity_role(request, para):
try:
activity = Activity.objects.filter(id=int(para.activity_id)).first()
if not activity:
raise BusinessException(ERR_ACTIVITY_NOT_EXIST)
user, role = get_user(activity, request.user)
if not user:
raise BusinessException(ERR_USER_AUTH)
area = Area.objects.filter(del_flag=FLAG_NO, id=int(
para.area_id)).first() if para.area_id else None
d_area = Area.objects.filter(
del_flag=FLAG_NO, id=int(
para.direct_area_id)).first() if para.direct_area_id else None
result = activity_s.list_role_in_activity(request.user, activity, user,
role, para.keyword, area,
d_area, str2bool(para.all),
para.rows, para.page)
except Exception as ex:
logger.exception(ex)
return response_exception(ex, ex.message)
return response200({'c': SUCCESS[0], 'm': SUCCESS[1], 'd': result})
def work_in_team(account, subjudge, subjudge_team, sub_activity, phase,
project, area, direct_area, subject, keyword, page, rows):
my_user, role = get_user(subjudge.activity, account)
logger.info('user %s area %s wanna check works in subjudge_team %s' %
(my_user.id, my_user.area.id, subjudge_team.id))
qs = works(subjudge.activity,
sub_activity=sub_activity,
paragraph=phase,
paragraph_project=project,
subject=subject,
keyword=keyword,
area=area,
direct_area=direct_area)
work_id_list = [
w.work.id
for w in SubJudgeTeamWork.objects.filter(subjudge_team=subjudge_team)
]
qs = qs.filter(id__in=work_id_list)
paged_data, result = paging_by_page(qs, rows, page)
for each in paged_data:
result['items'].append(struct_work(each, my_user.area))
return result
def api_edit_activity_role(request, para):
try:
modify_role = Role.objects.filter(id=int(para.role_id)).first()
if not modify_role:
raise BusinessException(ERR_ACTIVITY_NOT_EXIST)
activity = modify_role.activity
user, role = get_user(activity, request.user)
if not user:
raise BusinessException(ERR_USER_AUTH)
# 非活动创建者则只能修改自己加入的用户（Role）
if not is_activity_owner(activity, request.user):
if (not role) or (modify_role.parent_role != role):
raise BusinessException(ERR_USER_AUTH)
result = activity_s.edit_activity_role(activity, user, role,
modify_role, para.new_username,
para.new_name, para.new_sex,
para.new_max)
except Exception as ex:
logger.exception(ex)
return response_exception(ex, ex.message)
return response200({'c': SUCCESS[0], 'm': SUCCESS[1], 'd': result})
