def create_user_request(cls, title, user_ID, **kwargs):
# create a new user_request object
user = UserBusiness.get_by_user_ID(user_ID)
created_user_request = UserRequestBusiness.add_user_request(
title=title,
user=user,
status=0,
**kwargs)
# 记录历史记录
statistics = StatisticsBusiness.action(
user_obj=user,
entity_obj=created_user_request,
entity_type="userRequest",
action="create"
)
# 记录世界频道消息 # 推送消息
world = WorldService.system_send(
channel=CHANNEL.request,
message=f"用户{created_user_request.user.user_ID}" +
f"发布了需求{created_user_request.title}")
# return created_user_request
# 不再记录到favor list里面
# todo
if created_user_request:
user_entity = UserService. \
action_entity(user_ID=user_ID,
entity_id=created_user_request.id,
action='star', entity='request')
return user_entity.entity
else:
raise RuntimeError('Cannot create the new user_request')
def list_projects(search_query=None,
page_no=1,
page_size=10,
default_max_score=0.4,
privacy=None,
type='project',
user_ID=None):
"""
list projects
:param user_ID:
:param order:
:param privacy:
:return:
"""
user = None
if user_ID:
user = UserBusiness.get_by_user_ID(user_ID)
cls = TypeMapper.get(type)
return cls.get_objects(
search_query=search_query,
privacy=privacy,
page_no=page_no,
page_size=page_size,
default_max_score=default_max_score,
user=user,
)
def get_my_course_with_detail(cls, user, page_no=1, page_size=10):
if isinstance(user, str):
user = UserBusiness.get_by_user_ID(user)
enroll_activity = CourseActivityBusiness.read({'user': user})
enroll_activity = enroll_activity(course__exists=True)
courses = [each_activity.course for each_activity in enroll_activity]
# 分页
total = len(courses)
courses = courses[(page_no - 1) * page_size:page_no * page_size]
for each_course in courses:
# 将 Activity的数据读取出来
num_of_activities = 0
objects_of_activities = []
for section in each_course.sections:
activities = CourseActivityBusiness.read({
'user':
user,
'course_section':
section
})
for a in activities:
# objects_of_activities.append(a.course_unit.to_mongo())
objects_of_activities.append(a.course_unit.zh_name)
num_of_activities += 1
# print(each_course)
# todo 以后查看是否有更好的方式, 因为这样做的话, 两门课包含了同一门就没办法进度同步了
total_unit = each_course.number_of_units
each_course.progress = num_of_activities * 1.0 / total_unit
each_course.total_unit = total_unit
each_course.learn_unit = num_of_activities
each_course.learn_activities = objects_of_activities
courses = json_utility.me_obj_list_to_json_list(courses)
return courses, total
def get_my_course(cls, user, page_no=1, page_size=10):
if isinstance(user, str):
user = UserBusiness.get_by_user_ID(user)
enroll_activity = CourseActivityBusiness.read({
'user': user,
'status': 'enroll'
})
enroll_activity = enroll_activity(course__exists=True)
courses = [each_activity.course for each_activity in enroll_activity]
# 分页
total = len(courses)
courses = courses[(page_no - 1) * page_size:page_no * page_size]
for each_course in courses:
# 将 Activity的数据读取出来
num_of_activities = 0
for section in each_course.sections:
num_of_activities += CourseActivityBusiness.read({
'user':
user,
'course_section':
section,
'status':
'enroll'
}).count()
# print(each_course)
# todo 以后查看是否有更好的方式, 因为这样做的话, 两门课包含了同一门就没办法进度同步了
total_unit = each_course.number_of_units
each_course.progress = num_of_activities * 1.0 / total_unit
each_course.total_unit = total_unit
each_course.learn_unit = num_of_activities
courses = json_utility.me_obj_list_to_json_list(courses)
return courses, total
def user_send(cls, user_ID, channel, message):
sender = UserBusiness.get_by_user_ID(user_ID)
world = WorldBusiness.user_send(sender=sender, channel=channel, message=message)
# world.sender_user_ID = world.sender.user_ID
logger_service.emit_world_message(world)
return world
def add_rating(cls, **kwargs):
# 取出UserId 和 App Id
# print(kwargs)
user = UserBusiness.get_by_user_ID(kwargs['user_ID'])
app = AppBusiness.get_by_id(kwargs['app'])
if user.user_ID == app.user.user_ID:
return []
rate = AppRatingBusiness.app_rating_repo.read({
'app': app,
'user': user
})
# print(rate)
if len(rate) > 0:
rate = rate[0]
# 进行更新内容, 但是不会添加新的记录
del kwargs['user_ID']
del kwargs['app']
# rate.update(**kwargs)
# rate.save()
# return cls._add_rate_info(rate)
# print(rate.id, kwargs)
return cls.update_rating(rate.id, **kwargs)
else:
kwargs['create_time'] = datetime.datetime.utcnow()
kwargs['user'] = user
kwargs['app'] = app
rate = AppRatingBusiness.add_rating(**kwargs)
return cls._add_rate_info(rate)
def two_step_vfc():
user_ID = get_jwt_identity()
data = request.get_json()
print(data)
check_type = data.pop("checkType")
check_value = data.pop("checkValue")
code = data.pop("code")
try:
result = False
if check_type == 'phone':
result = user_service.verify_code(code=code, phone=check_value)
elif check_type == 'email':
user = UserBusiness.get_by_user_ID(user_ID)
if code and code == user.emailCaptcha:
result = True
if result:
# 默认一周
expire_time = time.time() + 604800
response = {'response': {
'tokenForUpdateInfo': jwt.encode({'user_ID': user_ID,
'expireTime': expire_time},
UPDATE_USER_INFO_SK,
algorithm='HS256'),
}}
return jsonify(response), 200
except Error as e:
return jsonify({
"response": '验证码错误，请重新输入'}), 400
def get_statistics(cls, user_ID, page_no, page_size, action, entity_type):
"""
获取用户统计信息
这里需要将 app, caller 从objectID转换成json吗？
1. service可能被其他service调用，应该在route层转换
2. 在其他service调用时也都需要转换，保证route调用结果一致
:param user_ID:
:type user_ID:
:param page_no:
:type page_no:
:param page_size:
:type page_size:
:param action:
:type action:
:param entity_type:
:type entity_type:
:return:
:rtype:
"""
from server3.business.statistics_business import StatisticsBusiness
user_obj = UserBusiness.get_by_user_ID(user_ID=user_ID)
statistics = StatisticsBusiness.get_pagination(query={
"action": action,
"entity_type": entity_type,
"caller": user_obj
},
page_no=page_no,
page_size=page_size)
return statistics
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 refresh_token():
# Access the identity of the current user with get_jwt_identity
# current_user = get_jwt_identity()
claims = get_jwt_claims()
user = UserBusiness.get_by_user_ID(claims['user_ID'])
user = json_utility.convert_to_json(user.to_mongo())
return jsonify({'response': {'user': user}}), 200
def create_job(cls, project_id, type, user_ID, source_file_path,
run_args=None, running_module=None,
running_code=None):
business_mapper = {
'app': AppBusiness,
'module': ModuleBusiness,
'dataset': DatasetBusiness,
}
project = business_mapper[type].get_by_id(project_id)
options = {}
if running_module:
[modole_user_ID, module_name,
module_version] = running_module.split('/')
module_identity = f'{modole_user_ID}+{module_name}'
running_module = ModuleBusiness.get_by_identity(module_identity)
options = {
'running_module': running_module,
'module_version': module_version
}
user = UserBusiness.get_by_user_ID(user_ID)
new_job = JobBusiness.create_job(project=project, type=type, user=user, source_file_path=source_file_path,
run_args=run_args, running_code=running_code, **options)
# add job to project
project.jobs.append(new_job)
project.save()
return new_job
def get_statistics():
user_ID = get_jwt_identity()
page_no = int(request.args.get('page_no', 1))
page_size = int(request.args.get('page_size', 5))
action = request.args.get("action")
entity_type = request.args.get("entity_type")
user_obj = UserBusiness.get_by_user_ID(user_ID=user_ID)
statistics = StatisticsBusiness.get_pagination(query={
"action": action,
"entity_type": entity_type,
"caller": user_obj
},
page_no=page_no,
page_size=page_size)
for object in statistics.objects:
object.app_obj_user_ID = object.app.user.user_ID
return jsonify({
'response': {
"objects":
json_utility.objs_to_json_with_args(statistics.objects,
["app", "caller"]),
# "objects": json_utility.me_obj_list_to_json_list(statistics.objects),
# "objects": json.loads(statistics.objects.to_json()),
"page_size":
statistics.page_size,
"page_no":
statistics.page_no,
"count":
statistics.count,
}
})
def list_projects(cls,
search_query,
page_no=None,
page_size=None,
default_max_score=0.4,
privacy=None,
user_ID=None):
"""
list projects
:param search_query:
:type search_query:
:param page_no:
:type page_no:
:param page_size:
:type page_size:
:param default_max_score:
:type default_max_score:
:param privacy:
:type privacy:
:param user_ID:
:type user_ID:
:return:
:rtype:
"""
user = None
if user_ID:
user = UserBusiness.get_by_user_ID(user_ID)
return cls.business.get_objects(search_query=search_query,
privacy=privacy,
page_no=page_no,
page_size=page_size,
default_max_score=default_max_score,
user=user)
def get_statistics():
user_ID = get_jwt_identity()
page_no = int(request.args.get('page_no', 1))
page_size = int(request.args.get('page_size', 5))
action = request.args.get("action")
entity_type = request.args.get("entity_type")
user_obj = UserBusiness.get_by_user_ID(user_ID=user_ID)
statistics = StatisticsBusiness.get_pagination(
query={
"action": action,
"entity_type": entity_type,
"caller": user_obj
},
page_no=page_no, page_size=page_size)
# for object in statistics.objects:
# # print("tom", json_utility.convert_to_json(object.app.to_mongo()))
# # object.app_obj = "111"
# app = json.dumps(object.app.to_mongo())#json_utility.convert_to_json(object.app.to_mongo())
# object.app_obj = app
#
# # object = json_utility.convert_to_json(object.to_mongo())
# # object["app_obj"] = app
print("statistics.objects", statistics.objects)
return jsonify({
'response': {
"objects": json_utility.objs_to_json_with_args(statistics.objects, ["app", "caller"]),
"page_size": statistics.page_size,
"page_no": statistics.page_no,
"count": statistics.count,
}
})
def update_one_public_model():
"""
数据库建一个model的collection, 记载public的数据分析工具包简介
"""
user = UserBusiness.get_by_user_ID('system')
MNIST = Model(name='MNIST手写识别',
description='MNIST手写识别',
usage=0,
classification=0,
target_py_code="/lib/aaa/xxx",
input_data={
'shape': {
'DO': 550000,
'D1': 28,
'D2': 28
},
'ranks': 3,
'type': 'DT_FLOAT',
'target_input_addr': '/lib/xxx/aaa'
},
cnn_level=1,
evaluate_matrix=[0, 1],
optimization_algorithm=[0])
MNIST = model_repo.create(MNIST)
ownership_business.add(user, False, model=MNIST)
def send_message(cls, project, m_type='publish'):
receivers = project.favor_users # get app subscriber
admin_user = UserBusiness.get_by_user_ID('admin')
if m_type == 'deploy':
logger_service.emit_anything_notification(
{'message': {
'message_type': m_type
}}, project.user)
return
# 获取所有包含此module的答案
answers_has_module = RequestAnswerBusiness. \
get_by_anwser_project_id(project.id)
# 根据答案获取对应的 request 的 owner
for each_anser in answers_has_module:
user_request = each_anser.user_request
request_owener = user_request.user
message_service.create_message(
admin_user,
'publish_request', [request_owener],
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)
message_service.create_message(admin_user,
m_type,
receivers,
project.user,
project_name=project.name,
project_id=project.id,
project_type=project.type)
def list_projects_by_user_ID(user_ID, order=-1, privacy='all'):
"""
list all projects
:param user_ID:
:param order:
:param privacy:
:return:
"""
if not user_ID:
projects = ownership_service.get_all_public_objects('project')
else:
if privacy == 'all':
user = UserBusiness.get_by_user_ID(user_ID)
projects = ownership_service. \
get_ownership_objects_by_user_ID(user, 'project')
elif privacy == 'private':
projects = ownership_service. \
get_privacy_ownership_objects_by_user_ID(user_ID, 'project',
private=True)
elif privacy == 'public':
projects = ownership_service. \
get_privacy_ownership_objects_by_user_ID(user_ID, 'project',
private=False)
else:
projects = []
if order == -1:
projects.reverse()
return projects
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 get_list(cls,
type,
search_query,
user_ID,
page_no,
page_size,
search_tags,
sort,
query_user_ID,
rand,
related=False,
ref_project=None):
user = UserBusiness.get_by_user_ID(user_ID) if user_ID else None
query_user = UserBusiness.get_by_user_ID(
query_user_ID) if query_user_ID else None
if user:
user_request, total_number = UserRequestBusiness. \
get_list_by_user(type, user, page_no, page_size)
else:
user_request, total_number = UserRequestBusiness. \
get_list(type, search_query, user, False, page_no, page_size,
search_tags, sort, query_user, rand, related=related,
ref_project=ref_project)
if sort == 'hot':
for each_object in user_request:
each_object['input'] = []
each_object['output'] = []
each_object['view_num'] = EventBusiness.get_number({
'request':
each_object['_id'],
'action':
"view"
})
else:
for each_object in user_request:
each_object['input'] = []
each_object['output'] = []
each_object.view_num = EventBusiness.get_number({
'request':
each_object,
'action':
"view"
})
return user_request, total_number
def remove_by_user_ID(cls, user_ID):
user = UserBusiness.get_by_user_ID(user_ID)
removed_requests = UserRequestBusiness.remove_all_by_user(user)
# # todo 删除 Elasticsearch 的数据
# for removed in removed_requests:
# SearchService.delete_request(removed.id)
return removed_requests
def get_downloading_list(cls, project_id):
projects = ProjectBusiness.get_by_id(project_id)
user = UserBusiness.get_by_user_ID('momodel')
try:
downloading_list = DatasetBusiness.filter(
user=user, mount_kaggle_projects=projects, is_finished=False)
return downloading_list
except:
return False
def get_api_list(get_type, search_query, user_ID, page_no=default_page_no,
page_size=default_page_size, default_max_score=0.4):
start = (page_no - 1) * page_size
end = page_no * page_size
# apis = []
if get_type == ApiGetType.all:
# 获取所有的
if search_query:
# apis = Api.objects.search_text(search_query).order_by('$text_score')
apis = search(search_query)
else:
apis = api_business.get() # 分页
return apis.order_by('-create_time')[start:end]
elif get_type == ApiGetType.favor or get_type == ApiGetType.used or get_type == ApiGetType.star:
# 获取特定
user = UserBusiness.get_by_user_ID(user_ID=user_ID)
apis = user[get_type + "_apis"]
if search_query:
# 先search, 后用apis filter
match_apis = search(search_query)
final_apis = list(filter(lambda match_api: match_api in apis, match_apis))
apis = final_apis
return custom_sort(apis)[start:end]
elif get_type == ApiGetType.chat:
# 机器人
apis = api_business.get_all().order_by('-create_time')
# 比对打分
apis_score = []
for api in apis:
api_json = api.to_mongo()
apis_score.append({
**api_json,
"score": synonyms.compare(search_query, api.keyword, seg=True)
})
# TODO 以后可以更换成 object
# for api in apis:
# api.score = synonyms.compare(search_query, api.keyword, seg=True)
# api_json = api.to_mongo()
# apis_score.append({
# **api_json,
# "score": synonyms.compare(search_query, api.keyword, seg=True)
# })
apis_score = sorted(apis_score, key=lambda item: -item["score"])
# 最大值
max_score = apis_score[0]["score"]
if max_score < default_max_score:
raise Warning(ErrorMessage.no_match_apis)
else:
apis = apis_score
return apis[start:end]
else:
raise Error(ErrorMessage.error_get_type)
def favor_list(cls, user_ID, page_no, page_size):
user = UserBusiness.get_by_user_ID(user_ID=user_ID)
kaggle_favor = user.kaggle_dataset_favor
print('kaggle_favor', kaggle_favor)
total_count = len(kaggle_favor)
user_kaggle_favors = kaggle_favor[(page_no - 1) * page_size:page_no *
page_size]
# kaggle_favor_list = KaggleDatasetBusiness.favor_list(user_kaggle_favor, page_no, page_size)
# kaggle_favor_list = json_utility.me_obj_list_to_json_list(user_kaggle_favor)
return user_kaggle_favors, total_count
def update_user_email(cls, user_ID, email, captcha):
user = UserBusiness.get_by_user_ID(user_ID)
if captcha and getattr(user, 'emailCaptcha',
None) and captcha == user.emailCaptcha:
user.email = email
user.emailCaptcha = None
user.save()
return user
else:
raise Error("验证码错误")
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 create_project(cls,
name,
description,
user_ID,
tags=None,
user_token='',
type='project',
**kwargs):
"""
Create a new project
:param name: str
:param description: str
:param user_ID: ObjectId
:param type: string (app/module/dataset)
:param tags: list of string
:param user_token: string
:return: a new created project object
"""
if tags is None:
tags = []
project_type = type
user = UserBusiness.get_by_user_ID(user_ID)
# message = "{}创建了app{}".format(user.name, name)
# world_business.system_send(channel=cls.channel, message=message)
project = cls.business.create_project(name=name,
description=description,
type=type,
tags=tags,
user=user,
user_token=user_token,
**kwargs)
from server3.service.user_service import UserService
user, project = UserService.action_entity(user_ID=project.user.user_ID,
entity_id=project.id,
action='favor',
entity=project.type)
from server3.service.world_service import WorldService
from server3.business.statistics_business import StatisticsBusiness
# 记录历史记录
# statistics = StatisticsBusiness.action(
# user_obj=user,
# entity_obj=project,
# entity_type=type,
# action="create"
# )
# 记录世界频道消息 # 推送消息
world = WorldService.system_send(
channel=CHANNEL.request,
message=f"用户{project.user.user_ID}创建了{project_type}: {project.name}"
)
return project
def get_rate_by_app_and_user(cls, user_ID, app_id):
user = UserBusiness.get_by_user_ID(user_ID)
app = AppBusiness.get_by_id(app_id)
rate = AppRatingBusiness.app_rating_repo.read({
'app': app,
'user': user
})
if len(rate) > 0:
rate = rate[0]
return cls._add_rate_info(rate)
return []
def create_user_request(cls, title, user_ID, **kwargs):
tags = kwargs.pop('tags', [])
select_project_id = kwargs.pop('select_project')
if select_project_id:
select_project = ProjectBusiness.get_by_id(select_project_id)
kwargs.update({'select_project': select_project})
# create a new user_request object
user = UserBusiness.get_by_user_ID(user_ID)
created_user_request = UserRequestBusiness.add_user_request(
title=title, user=user, status=0, **kwargs)
# todo 添加Elasticsearch的Request数据
SearchService.add_request(created_user_request.title,
created_user_request.description,
created_user_request.type,
created_user_request.user.username,
created_user_request.id)
# update tags
cls.update_tags(oldtags=[],
newtags=tags,
entity_type='request',
entities=[created_user_request])
# created_user_request.add_tags(tags)
EventBusiness.create_event(user=user,
target=created_user_request,
target_type="request",
action="create")
# 记录世界频道消息 # 推送消息
# world = WorldService.system_send(
# channel=CHANNEL.request,
# message=f"用户{created_user_request.user.user_ID}" +
# f"发布了需求{created_user_request.title}")
# admin_user = UserBusiness.get_by_user_ID('admin')
#
# text = f"<http://localhost:8899/discussion/{created_user_request.id}?type={created_user_request.type}|" \
# f"用户 {created_user_request.user.user_ID} 发布了需求 {created_user_request.title}>"
#
# SlackBusiness.send_message(user=admin_user, text=text, channel='general')
if ENV in ['PROD', 'MO']:
try:
text = f"[{created_user_request.user.username}]({WEB_ADDR}/profile/{created_user_request.user.user_ID})" \
f" 发布了话题 [{created_user_request.title}]({WEB_ADDR}/discussion/{created_user_request.id}?type={created_user_request.type})"
RocketChatBusiness.post_official_message(text=text)
except:
print('rc error')
# msg = json_utility.convert_to_json({
# 'user_ID': user_ID,
# 'content': '发布了新需求，快去看看吧',
# })
# socketio.emit('world_message', msg,
# namespace='/log/%s' % user_ID)
return created_user_request
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 update_project_by_identity(cls, project_name, **data):
"""
Update project
:param project_name:
:return: a new created project object
"""
[user_ID, project_name] = project_name.split('+')
user = UserBusiness.get_by_user_ID(user_ID)
return cls.repo.update_unique_one(dict(name=project_name, user=user),
data)
