def create_message(cls,
sender,
message_type,
receivers,
user=None,
**kwargs):
if user and isinstance(user, (str, ObjectId)):
user = UserBusiness.get_by_id(user)
if isinstance(sender, (str, ObjectId)):
sender = UserBusiness.get_by_id(sender)
receivers = [
UserBusiness.get_by_id(r) if isinstance(r, (str, ObjectId)) else r
for r in receivers
]
# create a new message object
created_message, created_receivers = MessageBusiness. \
add_message(sender,
message_type,
receivers,
user,
**kwargs)
if created_message:
logger_service.emit_notification(created_message,
created_receivers)
return created_message
else:
raise RuntimeError('Cannot create the new message')
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 update_user_account():
user_ID = get_jwt_identity()
data = request.get_json()
token_for_update_info = data['tokenForUpdateInfo']
phone = data.get('phone', None)
email = data.get('email', None)
password = data.get('password', None)
captcha = data.get('captcha', None)
payload = jwt.decode(token_for_update_info, UPDATE_USER_INFO_SK,
algorithm='HS256')
if payload['user_ID'] != user_ID or payload['expireTime'] < time.time():
return jsonify({'response': {'error': 'tokenError'}}), 400
elif phone:
# 更改手机
# 验证手机 验证码
try:
if UserBusiness.get_by_phone(phone):
return jsonify({
"response": {'error': "手机号已被注册，请更换手机号"}
}), 400
res = user_service.verify_code(code=captcha, phone=phone)
user = UserBusiness.get_by_user_ID(user_ID)
user.phone = phone
user.save()
return jsonify({'response': {
"user": json_utility.convert_to_json(user.to_mongo())
}}), 200
except Error as e:
return jsonify({
"response": {'error': "验证码错误"}
}), 400
elif email:
# 更改邮箱
# 验证邮箱 验证码
if UserBusiness.get_by_email(email):
return jsonify({
"response": {'error': "邮箱已被注册，请更换邮箱"}
}), 400
try:
user = UserService.update_user_email(user_ID, email, captcha)
return jsonify({'response': {
"user": json_utility.convert_to_json(user.to_mongo())
}}), 200
except Error as e:
return jsonify({
"response": {'error': e.args[0]}
}), 400
elif password:
UserBusiness.update_password(user_ID, password)
else:
return jsonify({'response': {'error': 'unkownError'}}), 400
return jsonify({'response': 'ok'}), 200
def get_user_statistics():
from server3.business.user_request_business import UserRequestBusiness
user_ID = request.args.get("user_ID", get_jwt_identity())
apps = UserBusiness.get_action_entity(
user_ID=user_ID, action_entity="favor_apps",
page_no=1, page_size=1)
favor_apps_count = apps.count
user = UserBusiness.get_by_user_ID(user_ID)
requests_count = UserRequestBusiness.request_number_of_this_user(user)
return jsonify({'response': {
"favor_apps_count": favor_apps_count,
"requests_count": requests_count
}}), 200
def register():
data = request.get_json()
user_ID = data['user_ID']
password = data['password']
email = data['email']
code = data.pop('code')
captcha = data.pop("captcha")
phone = data.pop('phone')
data.pop('user_ID')
data.pop('password')
if user_ID is None or password is None or code is None:
return jsonify({'response': 'invalid user or password'}), 400
# 检查user_ID phone email 是否被占用
if UserBusiness.check_exist({'user_ID': user_ID}):
return jsonify({"response": {
"error": "this user_ID has been used,please try an other one"}}), 400
if UserBusiness.check_exist({'phone': phone}):
return jsonify({"response": {
"error": "this phone number has been used,please try an other one"}}), 400
if UserBusiness.check_exist({'email': email}):
return jsonify({"response": {
"error": "this email has been used,please try an other one"}}), 400
# 检查 captcha
try:
res = user_service.verify_code(code=captcha, phone=phone)
except Error:
return jsonify({
"response": {'error': "验证码错误"}
}), 400
# 建立用户并创建tutorial project
try:
added_user = user_service.register(user_ID, password, phone, code,
**data)
added_user = json_utility.convert_to_json(added_user.to_mongo())
added_user.pop('password')
# 为新用户创建tutorial project
from server3.service.project_service import ProjectService
from server3.service.app_service import AppService
user_token = create_access_token(identity=added_user["user_ID"])
AppService.create_tutorial_project(
user_ID=added_user["user_ID"],
user_token=user_token
)
return jsonify({'response': added_user}), 200
except Error as e:
return jsonify({
"response": {"error": e.args[0]}
}), 400
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 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 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 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 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 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 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 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 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 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 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_action_entity():
user_ID = request.args.get("user_ID")
action_entity = request.args.get("action_entity")
page_no = int(request.args.get('page_no', 1))
page_size = int(request.args.get('page_size', 5))
type = request.args.get('type', None)
search_query = request.args.get('search_query', None)
apps = UserBusiness.get_action_entity(
user_ID=user_ID, action_entity=action_entity, type=type,
page_no=page_no, page_size=page_size, search_query=search_query)
if action_entity != 'request_star':
for app in apps.objects:
app.user_ID = app.user.user_ID
else:
for each_request in apps.objects:
each_request.answer_number = RequestAnswerBusiness. \
answer_number_of_user_request(each_request.id)
each_request.user_ID = each_request.user.user_ID
return jsonify({
'response': {
"objects": json_utility.me_obj_list_to_json_list(apps.objects),
"page_size": apps.page_size,
"page_no": apps.page_no,
"count": apps.count,
}
})
def login_with_phone():
"""
通过手机号登录，
:return:
:rtype:
"""
data = request.get_json()
phone = data.pop("phone")
# message_id = data.pop("message_id")
code = data.pop("code")
if not UserBusiness.check_exist({'phone': phone}):
return jsonify({"response": {
"error": "This phone number is not registered, "
"please input the right phone number"}}), 400
try:
result = user_service.verify_code(code=code, phone=phone)
if result:
user = user_business.get_by_phone(phone=phone)
response = {'response': {
'token': create_access_token(identity=user.user_ID),
'user': json_utility.convert_to_json(user.to_mongo())}}
return jsonify(response), 200
except Error as e:
return jsonify({
"response": {
"error": 'Please enter correct verify code'
}
}), 400
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():
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 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:
# # 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 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 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
