def no_learning(user_ID):
user = user_business.get_by_user_ID(user_ID)
if user:
user['welcome'] = "1"
user.save()
return user
return False
def star_api(user_ID, api_id):
"""
:param user_ID:
:type user_ID:
:param api_id:
:type api_id:
:return:
:rtype:
"""
user = user_business.get_by_user_ID(user_ID=user_ID)
api = api_business.get_by_api_id(api_id=api_id)
# user_result, api_result = None, None
# 1. 在user下存star_apis
if api not in user.star_apis:
user.star_apis.append(api)
user_result = user.save()
else:
user.star_apis.remove(api)
user_result = user.save()
# 2. 在api下存star_users
if user not in api.star_users:
api.star_users.append(user)
api_result = api.save()
else:
api.star_users.remove(user)
api_result = api.save()
if user_result and api_result:
return {"user": user_result.to_mongo(), "api": api_result.to_mongo()}
def update_one_public_model():
"""
数据库建一个model的collection, 记载public的数据分析工具包简介
"""
user = user_business.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 no_tourtip(user_ID):
user = user_business.get_by_user_ID(user_ID)
if user:
user['tourtip'] = "1"
user.save()
return user
return False
def list_user_request_comments_by_user_id(user_ID, order=-1):
user = user_business.get_by_user_ID(user_ID)
user_request_comments = ownership_business. \
get_ownership_objects_by_user(user, 'user_request_comments')
if order == -1:
user_request_comments.reverse()
return user_request_comments
def add_toolkit_with_ownership(name, description, target_py_code,
entry_function, parameter_spec, user_ID,
is_private):
toolkit = toolkit_business.add(name, description, target_py_code,
entry_function, parameter_spec)
user = user_business.get_by_user_ID(user_ID)
ownership_business.add(user, is_private, toolkit=toolkit)
def list_request_answer_by_user_id(user_ID, order=-1):
user = user_business.get_by_user_ID(user_ID)
request_answer = ownership_business. \
get_ownership_objects_by_user(user, 'request_answer')
if order == -1:
request_answer.reverse()
return request_answer
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 = user_business.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 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 = user_business.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 deploy(cls, app_id, handler_file_path):
app = cls.business.deploy(app_id, handler_file_path)
receivers = app.favor_users # get app subscriber
admin_user = user_business.get_by_user_ID('admin')
message_service.create_message(admin_user, 'deploy', receivers,
app.user, app_name=app.name,
app_id=app.id)
return app
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 = user_business.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 publish(cls, project_id):
module = cls.business.publish(project_id)
receivers = module.favor_users # get app subscriber
admin_user = user_business.get_by_user_ID('admin')
message_service.create_message(admin_user,
'publish',
receivers,
module.user,
module_name=module.name,
module_id=module.id)
return module
def list_by_user_ID(user_ID):
"""
list all owned items of a user, by user_ID
:param user_ID:
:return: ownership list
"""
user = user_business.get_by_user_ID(user_ID)
if user:
return ownership_business.list_ownership_by_user(user)
else:
raise NameError('no user found')
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 = user_business.get_by_user_ID(user_ID)
return cls.repo.update_unique_one(dict(name=project_name, user=user),
data)
def get_all_public_projects_of_others(user_ID):
user = user_business.get_by_user_ID(user_ID)
ownerships = ownership_business.list_ownership_by_type_and_private(
'project', False)
projects = [
get_owned_item_with_user(os, 'project') for os in ownerships
if os.user != user
]
new_projects = sorted(projects,
key=itemgetter('create_time'),
reverse=True)
return new_projects
def commit_broadcast(project_id):
project = ProjectBusiness.get_by_id(project_id)
# ProjectBusiness.commit(project_id, commit_msg)
receivers = project.favor_users # get app subscriber
# commits = ProjectBusiness.get_commits(project.path)
admin_user = user_business.get_by_user_ID('admin')
message_service.create_message(admin_user,
'commit',
receivers,
project.user,
project_type=project.type,
project_id=project_id)
return jsonify({"response": 1})
def first_save_to_db(user_ID, name, description, input_info, output_info,
examples, version,
deploy_name, server,
input_type, model_base_path, job,
job_id, model_name, related_fields,
related_tasks, tags, is_private, data_fields,
input_data_demo_string,
service_name,projectId,
**optional):
"""
:param user_ID:
:param name:
:param description:
:param input_info:
:param output_info:
:param examples:
:param version:
:param deploy_name:
:param server:
:param input_type:
:param model_base_path:
:param job:
:param job_id:
:param is_private:
:param service_name:
:param model_name:
:param optional:
:return:
"""
user = user_business.get_by_user_ID(user_ID)
served_model = served_model_business.add(name, description, input_info,
output_info,
examples, version, deploy_name,
server, input_type,
model_base_path, job,
service_name, model_name,
related_fields,
related_tasks,
tags, is_private, data_fields,
input_data_demo_string,
create_time=datetime.utcnow(),
user=user, user_ID=user_ID,
projectId=projectId,
**optional)
ownership_business.add(user, is_private, served_model=served_model)
job_business.update_job_by_id(job_id, served_model=served_model)
return served_model
def create_user_request(title, user_ID, **kwargs):
# create a new user_request object
user = user_business.get_by_user_ID(user_ID)
created_user_request = user_request_business.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}发布了需求{created_user_request.title}"
)
if created_user_request:
# 默认发布者star
created_user_request = user_service.update_request_star(
created_user_request.id, user_ID)
# get user object
user = user_business.get_by_user_ID(user_ID=user_ID)
# create ownership relation
if ownership_business.add(user, user_request=created_user_request):
return created_user_request
else:
raise RuntimeError(
'Cannot create ownership of the new user_request')
else:
raise RuntimeError('Cannot create the new user_request')
def get_list(type,
search_query,
user_ID,
page_no,
page_size,
entity_type='userRequest'):
user = user_business.get_by_user_ID(user_ID) if user_ID else None
cls = EntityMapper.get(entity_type)
user_request, total_number = cls.get_list(type,
search_query,
user,
False,
page_no,
page_size,
get_total_number=True)
return user_request, total_number
def create_request_answer(**data):
# create a new request_answer object
created_request_answer = request_answer_business. \
add_request_answer(**data)
if created_request_answer:
# get user object
user = data['answer_user']
user_request = user_request_business. \
get_by_user_request_id(data['user_request'])
from server3.service.world_service import WorldService
from server3.business.statistics_business import StatisticsBusiness
from server3.entity.world import CHANNEL
# 记录历史记录
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 = user_business.get_by_user_ID('admin')
receivers = [el for el in user_request.star_user]
if message_service.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 get_ownership_objects_by_user_ID():
owned_type = request.args.get('owned_type')
user_ID = request.args.get('user_ID')
if not owned_type or not user_ID:
jsonify({'response': 'insufficient args'}), 400
try:
user = user_business.get_by_user_ID(user_ID)
ownerships = ownership_business.get_ownership_objects_by_user(
user, owned_type)
ownerships = [ownership.to_mongo() for ownership in ownerships]
ownerships = json_utility.convert_to_json(ownerships)
except DoesNotExist as e:
return jsonify({'response': '%s: %s' % (str(DoesNotExist), e.args)}), \
400
except Exception as e:
return jsonify({'response': '%s: %s' % (str(Exception), e.args)}), 400
return jsonify({'response': ownerships}), 200
def get_all_answer_by_user_ID(user_ID,
page_no,
page_size,
type,
search_query,
get_total_number=True):
cls = RequestAnswerBusiness
user = user_business.get_by_user_ID(user_ID)
answers, total_number = cls. \
get_by_answer_user(user,
search_query=search_query,
get_total_number=get_total_number,
page_no=page_no,
page_size=page_size,
type=type)
for answer in answers:
answer.user_request_title = answer.user_request.title
return answers, total_number
def add():
"""
:return:
:rtype:
"""
data = request.get_json()
try:
user_ID = data.pop("user_ID")
name = data.pop("name")
user = user_business.get_by_user_ID(user_ID)
result = api_business.add(name=name, user=user, **data)
result = json_utility.convert_to_json(result.to_mongo())
return jsonify({"response": result}), 200
except KeyError:
return jsonify({"response": {"message": "no enough params"}}), 300
except:
print("Unexpected error:", sys.exc_info()[0])
raise
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 = user_business.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
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 action(cls, user_ID, object_id):
user = user_business.get_by_user_ID(user_ID=user_ID)
app = cls.business.get_by_id(project_id=object_id)
if app not in user[cls.user_keyword]:
user[cls.user_keyword].append(app)
user_result = user.save()
else:
user[cls.user_keyword].remove(app)
user_result = user.save()
# 2. 在app下存favor_users
if user not in app[cls.object_keyword]:
app[cls.object_keyword].append(user)
app_result = app.save()
else:
app[cls.object_keyword].remove(user)
app_result = app.save()
if user_result and app_result:
return UserEntity(user=user_result, entity=app_result)
def update_request_star(user_request_id, user_ID):
user = user_business.get_by_user_ID(user_ID)
user_request = user_request_business. \
get_by_user_request_id(user_request_id)
if user_request in user.request_star:
user.request_star.remove(user_request)
user_result = user.save()
else:
user.request_star.append(user_request)
user_result = user.save()
if user in user_request.star_user:
user_request.star_user.remove(user)
user_request_result = user_request.save()
else:
user_request.star_user.append(user)
user_request_result = user_request.save()
if user_result and user_request_result:
return user_request_result
def update_request_vote(user_request_id, user_ID):
user = user_business.get_by_user_ID(user_ID)
user_request = user_request_business. \
get_by_user_request_id(user_request_id)
if user_request in user.request_vote_up:
user.request_vote_up.remove(user_request)
user_result = user.save()
else:
user.request_vote_up.append(user_request)
user_result = user.save()
if user in user_request.votes_up_user:
user_request.votes_up_user.remove(user)
user_request_result = user_request.save()
else:
user_request.votes_up_user.append(user)
user_request_result = user_request.save()
if user_result and user_request_result:
return user_request_result.to_mongo()
def add_used_api(user_ID, api_id):
"""
为用户增加 使用过的api
:param user_ID:
:type user_ID:
:param api_id:
:type api_id:
:return:
:rtype:
"""
user = user_business.get_by_user_ID(user_ID=user_ID)
api = api_business.get_by_api_id(api_id=api_id)
user_result = None
if api not in user.used_apis:
user.used_apis.append(api)
user_result = user.save()
if user_result:
return {
"user": user_result.to_mongo(),
}
def create_user_request_comments(user_request_id, user_ID, comments,
comments_type, request_answer_id):
# create a new user_request_comments object
created_user_request_comments = comments_business.\
add_user_request_comments(user_request_id=user_request_id,
comments_user_ID=user_ID,
comments=comments,
comments_type=comments_type,
request_answer_id=request_answer_id)
if created_user_request_comments:
# get user object
user = user_business.get_by_user_ID(user_ID=user_ID)
# create ownership relation
if ownership_business.add(
user, user_request_comments=created_user_request_comments):
return created_user_request_comments
else:
raise RuntimeError(
'Cannot create ownership of the new user_request_comments')
else:
raise RuntimeError('Cannot create the new user_request_comments')
def update_answer_vote(request_answer_id, user_ID):
user = user_business.get_by_user_ID(user_ID)
request_answer = request_answer_business. \
get_by_request_answer_id(request_answer_id)
if request_answer in user.answer_vote_up:
user.answer_vote_up.remove(request_answer)
user_result = user.save()
else:
user.answer_vote_up.append(request_answer)
user_result = user.save()
if user in request_answer.votes_up_user:
request_answer.votes_up_user.remove(user)
request_answer_result = request_answer.save()
else:
request_answer.votes_up_user.append(user)
request_answer_result = request_answer.save()
if user_result and request_answer_result:
return request_answer_result.to_mongo()
