def submit_review(request):
"""
设置评审专家
:param request:
:return:
"""
request_body = json.loads(request.body)
project_id = request_body.get('project_id')
user_name_list = request_body.get('review_list')
print user_name_list
user_list = UserLoinInterface.get_user_list_by_name_list(
user_name_list).get('results')
temp = ProjectInterface.change_project_status(project_id=project_id,
project_status=2)
for i in user_list:
review_id = uuid.uuid1()
init_review_res = ReviewInterface.init_review(
review_id=review_id,
review_user_id=i.get('user_id'),
review_user_name=i.get('user_name'),
project_id=project_id)
if init_review_res.get('code') == 0:
res = success_return(u'设置评审专家成功', None)
continue
else:
ReviewInterface.delete_review(review_id=review_id)
ProjectInterface.change_project_status(project_id=project_id,
project_status=1)
res = success_return(u'设置评审专家失败', None)
return render_json(res)
return render_json(res)
def get_notices(cls, page, page_size):
"""
获取通知
:param page: 页数
:param page_size:
:return:
"""
result_list = []
if page == 0:
# 全部取出
pass
else:
notices = Notification.objects.values().all().order_by(
'-create_time')
paginator = Paginator(notices, page_size)
temp_list = paginator.page(page)
for i in temp_list:
i['create_time'] = i['create_time'].strftime(
"%Y-%m-%d %H:%M:%S")
i['page'] = page
i['page_count'] = paginator.num_pages
i['count'] = paginator.count
result_list.append(i)
return success_return(u'获取通知成功', result_list)
def get_accessories_by_project_id(cls, project_id, page, page_size):
"""
通过项目ID获取附件list 空则返回[]
:param project_id:
:param page:
:param page_size:
:return:
"""
result_list = []
if page == 0:
try:
accessories = Accessories.objects.values().filter(
project_id=project_id).order_by('-accessories_time')
for i in accessories:
i['accessories_time'] = i['accessories_time'].strftime(
"%Y-%m-%d %H:%M:%S")
result_list.append(i)
except:
pass
else:
accessories = Accessories.objects.values().filter(
project_id=project_id).order_by('-accessories_time')
paginator = Paginator(accessories, page_size)
temp_list = paginator.page(page)
for i in temp_list:
i['accessories_time'] = i['accessories_time'].strftime(
"%Y-%m-%d %H:%M:%S")
i['page'] = page
i['page_count'] = paginator.num_pages
i['count'] = paginator.count
result_list.append(i)
return success_return('获取附件成功', result_list)
def get_user_login_list(cls, page, page_size):
"""
获取用户列表
:param page:
:param page_size:
:return:
"""
result_list = []
if page == 0:
try:
user_login_list = UserLogin.objects.values().all().order_by(
'user_id')
for i in user_login_list:
result_list.append(i)
except:
pass
else:
accessories = UserLogin.objects.values().all().order_by('user_id')
paginator = Paginator(accessories, page_size)
temp_list = paginator.page(page)
for i in temp_list:
i['page'] = page
i['page_count'] = paginator.num_pages
i['count'] = paginator.count
result_list.append(i)
return success_return(u'获取用户登录信息成功', result_list)
def get_all_science_type(cls):
"""
获取所有科研类型
:return:
"""
result_list = []
science_type_list = ScienceType.objects.values().all()
for i in science_type_list:
result_list.append(i)
return success_return(u'获取科研类型陈宫', result_list)
def get_user_login_by_id(cls, user_id):
"""
通过用户ID获取用户信息
:param user_id:
:return:
"""
try:
query_result = UserLogin.objects.values().get(user_id=user_id)
return success_return(u'获取用户登录信息成功', query_result)
except Exception as e:
return error_return(u'获取用户登录信息失败')
def get_username_by_session(request):
"""
通过session获取用户名
:param request:
:return:
"""
try:
username = request.session.get('user')['username']
res = success_return(u'获取用户名成功', {'username': username})
except Exception as e:
res = error_return(u'获取用户名失败')
return render_json(res)
def delete_review(cls, review_id):
"""
删除评审信息
:param review_id:
:return:
"""
try:
with transaction.atomic():
Review.objects.get(review_id=review_id).delete()
return success_return(u'删除成功', None)
except Exception as e:
return error_return(u'删除失败')
def get_user_all_info(request):
"""
获取所有用户信息
:param request:
:return:
"""
user_login = UserLoinInterface.get_user_login_list(page=0, page_size=0)
try:
res = UserInfoInterface.get_user_detail_list_by_user_login(
user_login_list=user_login.get('results'))
return render_json(success_return(u'获取用户列表成功', res))
except Exception as e:
return render_json(error_return(u'获取用户列表失败' + str(e)))
def get_review_list_by_project_id(cls, project_id):
"""
通过项目ID获取审批信息
:param project_id:
:return:
"""
result_list = []
review = Review.objects.values().filter(
project_id=project_id).order_by('-review_time')
for i in review:
i['review_time'] = i['review_time'].strftime("%Y-%m-%d %H:%M:%S")
result_list.append(i)
return success_return(u'获取评审信息列表成功', result_list)
def get_user_list_by_type(cls, user_type):
"""
:param user_type:
:return:
"""
result_list = []
try:
user_login = UserLogin.objects.values().filter(user_type=user_type)
for i in user_login:
result_list.append(i)
except:
pass
return success_return(u'获取用户列表成功', result_list)
def change_project_status(cls, project_id, project_status):
"""
更改项目状态
:param project_id:
:param project_status:
:return:
"""
try:
with transaction.atomic():
Project.objects.filter(project_id=project_id).update(
project_status=project_status)
return success_return(u'修改状态成功', None)
except Exception as e:
return error_return(u'修改项目状态失败')
def get_my_review_by_project_id(request):
"""
获取个人审批意见
:param request:
:return:
"""
project_id = request.session['project_id']
res = ReviewInterface.get_review_list_by_project_id(project_id=project_id)
user_id = request.session['user_id']
result_list = []
for i in res.get('results'):
if user_id == i.get('review_user_id'):
result_list.append(i)
return render_json(success_return(u'获取成功', result_list))
def get_notice_by_id(cls, notification_id):
"""
通过通知ID获取通知信息
:param notification_id:
:return:
"""
try:
notice = Notification.objects.values().get(
notification_id=notification_id)
notice['create_time'] = notice['create_time'].strftime(
"%Y-%m-%d %H:%M:%S")
return success_return(u'获取通知成功', notice)
except Exception as e:
return error_return(u'获取通知失败')
def get_user_list_by_name_list(cls, user_name_list):
"""
通过用户名列表获取用户列表
:param user_name_list:
:return:
"""
result_list = []
try:
user_login = UserLogin.objects.values().filter(
user_name__in=user_name_list)
for i in user_login:
result_list.append(i)
except:
pass
return success_return(u'获取用户列表成功', result_list)
def get_active_user_info(request):
"""
获取当前用户信息
:param request:
:return:
"""
user_id = request.session['user_id']
user_login = UserLoinInterface.get_user_login_by_id(user_id=user_id)
user_login_list = []
user_login_list.append(user_login.get('results'))
try:
res = UserInfoInterface.get_user_detail_list_by_user_login(
user_login_list=user_login_list)
return render_json(success_return(u'获取用户列表成功', res))
except Exception as e:
return render_json(error_return(u'获取用户列表失败' + str(e)))
def get_other_review_by_project_id(request):
"""
通过项目ID获取评审信息
:param request:
:return:
"""
project_id = request.session['project_id']
print project_id
res = ReviewInterface.get_review_list_by_project_id(project_id=project_id)
print res
user_id = request.session['user_id']
result_list = []
for i in res.get('results'):
if user_id != i.get('review_user_id'):
result_list.append(i)
return render_json(success_return(u'获取成功', result_list))
def user_login(cls, username, password):
"""
用户登陆验证
:param username: 用户名称
:param password: 用户密码
:return: json 0 验证成功 1 验证失败
"""
query_result = UserLogin.objects.filter(user_name=username)
if query_result is None:
return error_return(u'用户名不存在')
else:
query_dict = model_to_dict(query_result[0])
query_password = query_dict['user_password']
if query_password == password:
return success_return(u'登录成功', query_dict)
else:
return error_return(u'密码错误')
def update_review(cls, review_id, review_message, review_status):
"""
更新评审信息
:param review_id:
:param review_message:
:param review_status:
:return:
"""
try:
with transaction.atomic():
Review.objects.filter(review_id=review_id).update(
review_status=review_status,
review_message=review_message,
review_time=datetime.datetime.now())
return success_return(u'修改评审信息成功', None)
except Exception as e:
return error_return(u'修改评审信息失败')
def insert_science_type(cls, type_name):
"""
新增科研类型
:param type_name:
:return:
"""
type_id = uuid.uuid1()
try:
with transaction.atomic():
count = ScienceType.objects.filter(type_name=type_name).count()
if count == 0:
ScienceType.objects.create(type_id=type_id,
type_name=type_name)
return success_return(u'新增科研类型成功', None)
else:
return error_return(u'科研类型名称已存在')
except Exception as e:
return error_return(u'新增科研类型失败')
def update_science_type(cls, type_id, type_name):
"""
修改科研类型
:param type_id:
:param type_name:
:return:
"""
try:
with transaction.atomic():
count = ScienceType.objects.filter(type_name=type_name).count()
if count == 0:
ScienceType.objects.filter(type_id=type_id).update(
type_name=type_name)
return success_return(u'修改科研类型成功', None)
else:
return error_return(u'修改科研类型名称已存在')
except Exception as e:
return error_return(u'修改科研类型异常')
def get_specialist_group_by_science(cls):
"""
:return:
"""
result_list = []
temp_list = []
science_type_list = ScienceType.objects.values().all()
for i in science_type_list:
temp_list.append(i)
user_temp_list = []
user_login_list = UserLoinInterface.get_specialist_by_type_id(
science_type_id=i.get('type_id'))
for j in user_login_list:
user_temp_list.append(j)
i['user_list'] = user_temp_list
result_list.append(i)
return success_return(u'获取专家列表成功', result_list)
def insert_accessories(cls, project_id, accessories_id, accessories_name,
accessories_url):
"""
新增项目附件
:param project_id:
:param accessories_id:
:param accessories_name:
:param accessories_url:
:return:
"""
try:
with transaction.atomic():
Accessories.objects.create(project_id=project_id,
accessories_id=accessories_id,
accessories_name=accessories_name,
accessories_url=accessories_url)
return success_return(u'新增附件成功', None)
except Exception as e:
return error_return(u'新增附件失败' + str(e))
def init_review(cls, review_id, project_id, review_user_id,
review_user_name):
"""
初始化项目评审信息
:param review_id:
:param project_id:
:param review_user_id:
:param review_user_name:
:return:
"""
try:
# review_status: 0未审批 1审批通过 2审批完成
with transaction.atomic():
Review.objects.create(review_id=review_id,
project_id=project_id,
review_user_id=review_user_id,
review_status=0,
review_user_name=review_user_name)
return success_return(u'新增评审信息成功', None)
except Exception as e:
return error_return(u'新增评审信息失败')
def delete_accessories_by_accessories_id(cls, accessories_id):
"""
通过附件ID删除附件
:param accessories_id:
:return:
"""
try:
exit_temp = Accessories.objects.filter(
accessories_id=accessories_id)
print exit_temp
if len(exit_temp) != 0:
temp = Accessories.objects.filter(
accessories_id=accessories_id).delete()
return success_return(u'删除成功', None)
else:
return error_return(u'附件不存在删除失败')
# if temp is not None:
# return success_return(u'删除成功', None)
# else:
# return error_return(u'附件不存在删除失败')
except Exception as e:
return error_return(u'删除失败' + str(e))
def get_project_by_project_name(cls, project_name, page, page_size):
"""
:param project_name:
:param page:
:param page_size:
:return:
"""
result_list = []
project = Project.objects.values().filter(
project_name__icontains=project_name).order_by('-project_time')
paginator = Paginator(project, page_size)
temp_list = paginator.page(page)
for i in temp_list:
i['project_time'] = i['project_time'].strftime("%Y-%m-%d %H:%M:%S")
i['start_time'] = i['start_time'].strftime("%H:%M:%S")
i['stop_time'] = i['stop_time'].strftime("%H:%M:%S")
i['page'] = page
i['page_count'] = paginator.num_pages
i['count'] = paginator.count
result_list.append(i)
return success_return(u'获取申请成功', result_list)
def insert_notice(cls, notification_title, notification_content,
create_user_id):
"""
:param notification_title:
:param notification_content:
:param create_user_id:
:return:
"""
notification_id = uuid.uuid1()
try:
# 添加事物控制防止异常时事物不回滚，这里事物必须放在try...catch里面
# 否则事物被try...catch捕获了就不起作用了
with transaction.atomic():
Notification.objects.create(
notification_id=notification_id,
notification_title=notification_title,
notification_content=notification_content,
create_user_id=create_user_id)
return success_return(u'发布通知成功', [])
except Exception as e:
return error_return(u'新增通知失败')
def insert_project(cls, project_name, project_time, apply_user_name,
apply_user_id, research_content, technology_new,
expected_goal, participator, start_time, stop_time,
science_type_id):
"""
新增项目信息
:param project_name:
:param project_time:
:param apply_user_name:
:param apply_user_id:
:param research_content:
:param technology_new:
:param expected_goal:
:param participator:
:param start_time:
:param stop_time:
:param science_type_id:
:return:
"""
project_id = uuid.uuid1()
try:
with transaction.atomic():
Project.objects.create(project_id=project_id,
project_name=project_name,
project_time=project_time,
apply_user_name=apply_user_name,
apply_user_id=apply_user_id,
research_content=research_content,
technology_new=technology_new,
expected_goal=expected_goal,
participator=participator,
start_time=start_time,
stop_time=stop_time,
project_status=0,
science_type_id=science_type_id)
return success_return(u'新增项目成功', {'project_id': str(project_id)})
except Exception as e:
return error_return(u'新增项目失败' + str(e))
def add_user_info(
cls,
user_id,
user_name,
user_password,
user_type,
user_email,
user_address,
user_phone,
science_type_id,
):
"""
新增用户信息
:param user_id:
:param user_name:
:param user_password:
:param user_type:
:param user_email:
:param user_address:
:param user_phone:
:param science_type_id:
:return:
"""
try:
with transaction.atomic():
UserLogin.objects.create(user_password=user_password,
user_type=user_type,
user_name=user_name,
science_type_id=science_type_id,
user_id=user_id)
with transaction.atomic():
UserInfo.objects.create(user_id=user_id,
user_email=user_email,
user_address=user_address,
user_phone=user_phone)
return success_return(u'新增用户信息成功', None)
except Exception as e:
return error_return(u'新增用户信息失败' + str(e))
def get_project_statement(cls):
"""
获取审批报表
:return:
"""
result_list = []
temp_list = []
project_list = Project.objects.values().filter(
project_status__in=[2, 3, 4])
for i in project_list:
i['project_time'] = i['project_time'].strftime("%Y-%m-%d %H:%M:%S")
i['start_time'] = i['start_time'].strftime("%H:%M:%S")
i['stop_time'] = i['stop_time'].strftime("%H:%M:%S")
temp_list.append(i)
review_list = []
review_temp_list = ReviewInterface.get_review_list_by_project_id(
project_id=i.get('project_id'))
for j in review_temp_list.get('results'):
# j['review_time'] = j['review_time'].strftime("%Y-%m-%d %H:%M:%S")
review_list.append(j)
i['review_list'] = review_list
result_list.append(i)
return success_return(u'获取报表成功', result_list)
