def accept_answer(cls, user_request, user, request_answer):
# user = UserBusiness.get_by_user_ID(user_ID)
user_request.update(accept_answer=request_answer)
# UserRequestBusiness.update_by_id(
# user_request_id=user_request_id,
# accept_answer=request_answer
# )
EventBusiness.create_event(
user=user,
target=request_answer,
target_type="answer",
action="accept",
)
# 发消息给回答者（回答者是需求者自己，不通知）
admin_user = UserBusiness.get_by_user_ID('admin')
# 发送消息给的用户
if request_answer.user != user:
MessageService.create_message(
sender=admin_user,
message_type='accept_answer',
receivers=[request_answer.user],
user=user,
title='Notification',
user_request=user_request,
)
def marked_sample(cls, result_id, label):
# trigger two event
result = CSResultBusiness.read_by_id(result_id)
result.label = label
# print('after_result: ', result.to_mongo())
result.save()
# 打一个标都记录上去, 同一个标不重复记录
task = cls._add_marked_count(result.task.id)
# task.save()
# 如果打完标签
results = CSResultBusiness.read_all_by_id(task, task.evaluation)
sample_marked_for_user, need_marked_times, marked_times = \
cls._compute_sample_marked_count(results)
if sample_marked_for_user >= task.total_count:
# send notification
admin_user = UserBusiness.get_by_user_ID('admin')
# reciever = UserBusiness.get_by_id(task.sponsor.id)
# send notification
MessageService.create_message(
admin_user,
'cs_task_done',
[task.sponsor],
user=task.sponsor,
task=result.task,
project=result.task.module,
)
# all people is labeled, finish this task
if task.marked_count == task.total_count:
task.status = 2
task.save()
return cls._add_extra_info_with_task(task)
return None
def update_request_answer_by_id(cls, request_answer_id, user, **data):
old_select_project = RequestAnswerBusiness.get_by_id(
request_answer_id).select_project
new_answer = RequestAnswerBusiness.update_request_answer_by_id(
request_answer_id, **data)
EventBusiness.create_event(
user=user,
target=new_answer,
target_type="answer",
action="update",
)
user_request = new_answer.user_request
# 发消息给request提出者和关注者（回答者也关注了request，不通知回答者自己）
admin_user = UserBusiness.get_by_user_ID('admin')
# 发送消息给关注此需求的用户
receivers = user_request.favor_users
# 发送消息给提出此需求的用户
receivers.append(user_request.user)
# 发送消息给收藏此回答的用户
receivers.extend(new_answer.favor_users)
# 剔除回答者自己
if user in receivers:
receivers.remove(user)
MessageService.create_message(
sender=admin_user,
message_type='answer_update',
receivers=receivers,
user=user,
title='Notification',
user_request=user_request,
)
# 如果答案有附加project，且与旧的答案项目不一致,发消息给project的,(回答者添加自己的项目，不通知回答者自己)
if data.get('select_project') and data[
'select_project'] != old_select_project and data[
'select_project'].user != user:
MessageService.create_message(
sender=admin_user,
message_type='answer_project',
receivers=[data['select_project'].user],
user=user,
title='Notification',
user_request=user_request,
project=data['select_project'])
return new_answer
def create_message():
if not request.json \
or 'message_type' not in request.json:
return jsonify({'response': 'insufficient arguments'}), 400
data = request.get_json()
# 用于确定 message 的类型
message_type = data['message_type']
sender = data.get('sender', None)
title = data.get('title')
content = data.get('content', None)
# receivers is a list
receivers = data.get('receivers', [])
MessageService.create_message(sender, message_type,
receivers, title=title,
content=content)
return jsonify({'response': 'create message success'}), 200
def _dispatch(cls, non_exactly, task_id, evaluation):
# non_exactly = cls._get_crowd_sourcing_samples(test)
# choose the user
task = CSTaskBusiness.get_task_by_id(task_id)
count = len(non_exactly)
# real of users
real_of_users = UserBusiness.get_all()
# promise do not send self
# print(task.sponsor.user_ID)
real_of_users = [
user for user in real_of_users
if user.user_ID != task.sponsor.user_ID
]
# real_of_users = [user for user in real_of_users
# if user.user_ID != 'lu_xu_1']
# print("real_of_users:", [user.user_ID for user in real_of_users])
# print(type(real_of_users))
real_of_user_nums = np.arange(len(real_of_users)).tolist()
# dispatch
result = {}
# ever image has dispatch at least to three people
for sample_idx in range(count):
result[sample_idx] = {
'user': [
real_of_users[i] for i in random.sample(
real_of_user_nums,
random.sample(cls._choose_people, 1)[-1])
],
'sample':
non_exactly[sample_idx]
}
# print([user.user_ID for user in result[sample_idx]['user']])
# 往数据库插入信息
invited_users = []
for key in result.keys():
sample = result[key]['sample']
# 测试账号
# CSResultService.add_result(task_id, evaluation, 'lu_xu_1', sample,
# '')
for user in result[key]['user']:
# add the invited
if user.id not in invited_users:
invited_users.append(user.id)
CSResultBusiness.add_result(task_id, evaluation, user.user_ID,
sample, '')
# print(user.user_ID)
# invited users
message = MessageService.create_message(
UserBusiness.get_by_user_ID('admin'),
'cs_task_invited',
invited_users,
project=task.dataset,
task=task,
)
print('invited:', message.to_mongo())
def send_message(cls, job, m_type='job_success'):
if job.running_code:
job_type = 'function'
job_name = re.match(r'def (\S+)\(\S*\):.*',
job.running_code).group(1)
else:
job_type = 'module'
user_ID = job.running_module.module.user.user_ID
module_name = job.running_module.module.name
version = job.running_module.version
job_name = f'{user_ID}/{module_name}/{version}'
project = job.app or job.module or job.dataset
admin_user = UserBusiness.get_by_user_ID('admin')
MessageService.create_message(admin_user,
m_type, [job.user.id],
job.user,
job_name=job_name,
job_id=job.id,
job_type=job_type,
project_id=project.id,
project_type=project.type)
def get_message():
# 返回用户的所有的message
user_ID = get_jwt_identity()
# 如果用户没登陆，返回空
if user_ID is None:
return jsonify({'response': {'messages': [],
'total_number': 0}}), 200
# 目前先返回最近的100条，以后做消息中心了再做翻页
page_no = int(request.args.get("pageNo", 1))
page_size = int(request.args.get("pageSize", 100))
messages, total_number = MessageService.get_by_user_ID(user_ID, page_no,
page_size)
return jsonify({'response': {'messages': messages,
'total_number': total_number}}), 200
def send_message(cls, project, m_type='publish'):
receivers = project.favor_users # get app subscriber
# if m_type in ['deploy', 'deploy_fail', 'publish_fail']:
# logger_service.emit_anything_notification(
# {'message': {'message_type': m_type,
# 'project_type': project.type,
# 'project_name': project.name}},
# project.user)
# return
# get app subscriber and user himself
# receivers = project.favor_users
# receivers.append(project.user.id)
admin_user = UserBusiness.get_by_user_ID('admin')
# 获取所有包含此module的答案
answers_has_module = RequestAnswerBusiness. \
get_by_anwser_project_id(project.id)
# 根据答案获取对应的 request 的 owner
for each_answer in answers_has_module:
user_request = each_answer.user_request
request_owner = user_request.user
# send to request owner
MessageService.create_message(
admin_user,
f'{m_type}_request', [request_owner],
project.user,
project_name=project.name,
project_id=project.id,
user_request_title=user_request.title,
user_request_id=user_request.id,
project_type=project.type)
# send to request favor user
MessageService.create_message(
admin_user,
f'{m_type}_request',
user_request.star_user,
project.user,
project_name=project.name,
project_id=project.id,
user_request_title=user_request.title,
user_request_id=user_request.id,
project_type=project.type)
# send to project favor user
MessageService.create_message(admin_user,
m_type,
receivers,
project.user,
project_name=project.name,
project_id=project.id,
project_type=project.type)
def create_request_answer(cls, **data):
# create a new request_answer object
created_request_answer = RequestAnswerBusiness. \
add_request_answer(**data)
if created_request_answer:
# get user object
user = data['answer_user']
user_request = UserRequestBusiness. \
get_by_id(data['user_request'])
# 记录历史记录
statistics = StatisticsBusiness.action(
user_obj=user,
entity_obj=created_request_answer,
entity_type="requestAnswer",
action="create")
# 记录世界频道消息 # 推送消息
world = WorldService.system_send(
channel=CHANNEL.request,
message=f"用户{created_request_answer.answer_user.user_ID}为需求"
f"{user_request.title}创建了回答")
# create ownership relations
# 新建通知消息
admin_user = UserBusiness.get_by_user_ID('admin')
# receivers = [user_request.user.id]
receivers = [el for el in user_request.star_user]
if MessageService.create_message(
sender=admin_user,
message_type='answer',
receivers=receivers,
user=user,
title='Notification',
user_request=user_request,
):
return created_request_answer
else:
raise RuntimeError(
'Cannot create message of the new request_answer')
else:
raise RuntimeError('Cannot create the new request_answer')
def create_request_answer(cls, **data):
# create a new request_answer object
created_request_answer = RequestAnswerBusiness. \
add_request_answer(**data)
if created_request_answer:
# get user object
user = data['user']
# 记录历史记录
# statistics = StatisticsBusiness.action(
# user_obj=user,
# entity_obj=created_request_answer,
# entity_type="requestAnswer",
# action="create"
# )
EventBusiness.create_event(
user=user,
target=created_request_answer,
target_type="answer",
action="create",
)
if data.get('user_request'):
user_request = data['user_request']
# 记录世界频道消息 # 推送消息
# world = WorldService.system_send(
# channel=CHANNEL.request,
# message=f"用户{created_request_answer.answer_user.user_ID}为需求"
# f"{user_request.title}创建了回答")
# admin_user = UserBusiness.get_by_user_ID('admin')
#
# text = f"<http://localhost:8899/discussion/{user_request.id}?type={user_request.type}|" \
# f"用户 {created_request_answer.answer_user.user_ID} 为需求 {user_request.title} 创建了回答>"
#
# SlackBusiness.send_message(user=admin_user, text=text, channel='general')
try:
text = f"[{created_request_answer.user.username}]({WEB_ADDR}/profile/{created_request_answer.user.user_ID})" \
f" 评论了话题 [{user_request.title}]({WEB_ADDR}/discussion/{user_request.id}?type={user_request.type}) "
RocketChatBusiness.post_official_message(text=text)
except:
print('rc error')
try:
# 发消息给request提出者和关注者（回答者也关注了request，不通知回答者自己）
admin_user = UserBusiness.get_by_user_ID('admin')
# 发送消息给关注此需求的用户
receivers = user_request.favor_users
# 发送消息给提出此需求的用户
receivers.append(user_request.user)
# 剔除回答者自己
if user in receivers:
receivers.remove(user)
MessageService.create_message(
sender=admin_user,
message_type='answer',
receivers=receivers,
user=user,
title='Notification',
user_request=user_request,
)
# 如果答案有附加project，发消息给project的作者,(回答者添加自己的项目，不通知回答者自己)
if data.get('select_project'
) and data['select_project'].user != user:
MessageService.create_message(
sender=admin_user,
message_type='answer_project',
receivers=[data['select_project'].user],
user=user,
title='Notification',
user_request=user_request,
project=data['select_project'])
except:
raise RuntimeError(
'Cannot create message of the new request_answer')
return created_request_answer
else:
raise RuntimeError('Cannot create the new request_answer')
def read_message():
data = request.get_json()
receiver_id = data['receiver_id']
user_ID = get_jwt_identity()
MessageService.read_message(user_ID, receiver_id)
return jsonify({'response': 'update success'}), 200
def job_call_the_filter(cls, task_id, if_success=True):
task = CSTaskBusiness.get_task_by_id(task_id)
# print(task_id, if_success)
# print(task.to_mongo())
if if_success:
# read pickle
module = ProjectBusiness.get_by_id(task.module.id)
file_path = os.path.join(module.path, 'results', str(task.id),
'sample.pkl')
try:
with open(file_path, 'rb') as file:
non_exactly = pickle.load(file)
# file.close()
# print('non_exactly:', non_exactly)
if len(non_exactly.values()) > 2:
# raise RuntimeError('The pickle file is not valid.')
task.status = 2
task.user_operation = True
task.save()
_ = MessageService.create_message(
UserBusiness.get_by_user_ID('admin'),
'cs_task_pickle_file_invalid', [task.sponsor],
user=task.sponsor,
task=task,
project=task.module)
return
if len(non_exactly['results']) > 0:
#
task.status = 2
task.user_operation = True
task.save()
_ = MessageService.create_message(
UserBusiness.get_by_user_ID('admin'),
'cs_task_done', [task.sponsor],
user=task.sponsor,
task=task,
project=task.module)
return
# print(file_path, non_exactly)
# print(non_exactly)
unmarked_set = cls._filter_probabilities(
[non_exactly['results'], non_exactly['max_choose']])
# print(unmarked_set)
if len(unmarked_set) > 0:
task.status = 0
task.evaluation += 1
task.total_count += len(unmarked_set)
cls._dispatch(unmarked_set, task_id, task.evaluation)
task.save()
# send notification to user
message = MessageService.create_message(
UserBusiness.get_by_user_ID('admin'),
'cs_task_start', [task.sponsor],
user=task.sponsor,
task=task,
project=task.module)
# print('success:', message.to_mongo())
return task
else:
task.status = 2
task.user_operation = True
# return {'msg': 'This task has occurred error when executed, '
# 'you can check it in your module job page.'}
# send notification to user
task.save()
message = MessageService.create_message(
UserBusiness.get_by_user_ID('admin'),
'cs_task_done', [task.sponsor],
user=task.sponsor,
task=task,
project=task.module)
print('no unlabeled:', message.to_mongo())
except FileNotFoundError as e:
# return {'msg': 'your module don`t create the pickle file.'}
# send notification to user
task.status = 2
task.user_operation = True
task.save()
task = cls._add_extra_info_with_task(task)
message = MessageService.create_message(
UserBusiness.get_by_user_ID('admin'),
'cs_task_pickle_file_not_found',
[task.sponsor],
task=task,
project=task.module,
)
# , 'project': task.module
print("file not found:", message.to_mongo())
except Exception as e:
# return {'msg': 'error occur.'}
print(e)
task.status = 2
task.user_operation = True
task.save()
task = cls._add_extra_info_with_task(task)
message = MessageService.create_message(
UserBusiness.get_by_user_ID('admin'),
'cs_task_job_error', [task.sponsor],
task=task,
user=task.sponsor,
project=task.module)
# , 'project': task.module
print('exception:', e, 'message:', message.to_mongo())
raise RuntimeError(e)
else:
task.status = 2
task.user_operation = True
# task.evaluation -= 1
if task.evaluation > 1:
message = MessageService.create_message(
UserBusiness.get_by_user_ID('admin'),
'cs_task_job_error',
[task.sponsor],
user=task.sponsor,
task=task,
project=task.module,
)
# , 'project': task.module
print('train, has exception:', message.to_mongo())
task.save()