def get_all_course(cls, page_no, page_size):
courses = CourseBusiness.read()
total = len(courses)
video_course = courses(course_type='video')
practice_course = courses(course_type='practice')
doc_course = courses(course_type='doc')
video_course = video_course[(page_no - 1) * page_size:page_no *
page_size]
practice_course = practice_course[(page_no - 1) * page_size:page_no *
page_size]
doc_course = doc_course[(page_no - 1) * page_size:page_no * page_size]
return {
'video': json_utility.me_obj_list_to_json_list(video_course),
'practice': json_utility.me_obj_list_to_json_list(practice_course),
'doc': json_utility.me_obj_list_to_json_list(doc_course)
}, 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 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 list_files_by_user_ID():
user_ID = request.args.get('user_ID')
extension = request.args.get('extension')
predict = request.args.get('predict')
predict = str(predict).lower() == 'true'
if not user_ID:
return jsonify({'response': 'insufficient args'}), 400
public_files, owned_files = \
file_service.list_file_by_extension(user_ID,
extension=extension,
predict=predict,
order=-1)
public_files = json_utility.me_obj_list_to_json_list(public_files)
owned_files = json_utility.me_obj_list_to_json_list(owned_files)
result = {'public_files': public_files, 'owned_files': owned_files}
return jsonify({'response': result})
def list_all_served_models(user_ID=None, related_fields=None, related_tasks=None, tags=None,
privacy=None, skipping=None, search_str=None):
"""
:param related_fields:
:param related_tasks:
:param tags:
:param privacy:
:param skipping:
:param search_str:
:return:
"""
public_all = served_model_business.get_by_query(
user_ID=user_ID,
related_fields=related_fields,
related_tasks=related_tasks,
tags=tags, skipping=skipping,
privacy=privacy,
search_str=search_str)
# public_all = [each_model.to_mongo() for each_model in public_all]
public_all = json_utility.me_obj_list_to_json_list(
public_all)
# myyy = [a['_id'] for a in public_all]
# print(myyy)
# print(public_all)
return public_all
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 list_data_sets_by_user_ID():
user_ID = get_jwt_identity()
related_field = request.args.get('related_field')
tag = request.args.get('tag')
related_task = request.args.get('related_task')
extension = request.args.get('extension')
type = request.args.get('type')
if not user_ID:
jsonify({'response': 'insufficient args'}), 400
if user_ID:
public_ds, owned_ds = data_service. \
list_data_sets_by_user_ID(user_ID, -1,
related_field=related_field, tag=tag,
related_task=related_task,
extension=extension,
file_type=type)
public_ds = json_utility.me_obj_list_to_json_list(public_ds)
owned_ds = json_utility.me_obj_list_to_json_list(owned_ds)
result = {'public_ds': public_ds, 'owned_ds': owned_ds}
return jsonify({'response': result}), 200
return jsonify({'response': 'insufficient arguments'}), 400
def check_integrity(staging_data_set_id):
"""
check_integrity
:param staging_data_set_id:
:return:
"""
data_objects = staging_data_business. \
get_by_staging_data_set_id(staging_data_set_id)
# convert mongoengine objects to dicts
data_objects = json_utility.me_obj_list_to_json_list(data_objects)
data_fields = get_fields_with_types(staging_data_set_id)
return data_service.check_data_integrity(data_objects, data_fields)
def get_by_model_id(model_ID):
"""
:param category:
:return:
"""
model = served_model_business.get_by_id(model_ID)
# public_all = [each_model.to_mongo() for each_model in public_all]
model = json_utility.me_obj_list_to_json_list(
[model])
print(model)
model[0] = build_how_to_use_code(model[0])
return model
def get_data_set(data_set_id):
limit = request.args.get('limit')
is_last = request.args.get('isLast')
if not limit:
limit = 100
if is_last == 'true':
data = data_business.get_last_limit_by_data_set(
ObjectId(data_set_id), int(limit))
else:
data = data_business.get_by_data_set_limit(ObjectId(data_set_id),
int(limit))
data = json_utility.me_obj_list_to_json_list(data)
fields = data_service.get_fields_with_types(ObjectId(data_set_id))
fields = {e[0]: e[1] for e in fields}
return jsonify({'response': data, 'fields': fields}), 200
def list_projects_by_query():
group = request.args.get('group')
page_no = int(request.args.get('page_no', 1))
page_size = int(request.args.get('page_size', 5))
search_query = request.args.get('query', None)
privacy = request.args.get('privacy', None)
default_max_score = float(request.args.get('max_score', 0.4))
type = request.args.get('type', 'project')
tags = request.args.get('tags', None)
if tags:
tags = tags.split(',')
if group == 'my':
user_ID = get_jwt_identity()
else:
user_ID = None
privacy = 'public'
try:
projects = project_service.list_projects(
search_query=search_query,
privacy=privacy,
type=type,
page_no=page_no,
page_size=page_size,
default_max_score=default_max_score,
user_ID=user_ID,
tags=tags)
except Warning as e:
return jsonify({
"response": [],
"message": e.args[0]["hint_message"]
}), 200
except Error as e:
return jsonify({"message": e.args[0]["hint_message"]}), 404
else:
for project in projects.objects:
project.user_ID = project.user.user_ID
# if project.user.avatar:
# project.user_avatar = project.user.avatar
project_list = json_utility.me_obj_list_to_json_list(projects.objects)
return jsonify(
{"response": {
'projects': project_list,
'count': projects.count
}}), 200
def get_chat_api_list():
"""
带搜索关键字的,
:return:
:rtype:
"""
# user_ID = get_jwt_identity()
page_no = int(request.args.get('page_no', 1))
page_size = int(request.args.get('page_size', 5))
search_query = request.args.get('search_query', None)
default_max_score = float(request.args.get('max_score', 0.1))
privacy = request.args.get('privacy')
if not search_query:
return jsonify({'response': 'no search_query arg'}), 400
try:
api_list = AppBusiness.list_projects_chat(
search_query,
page_no=page_no,
page_size=page_size,
default_max_score=default_max_score,
privacy=privacy)
except Warning as e:
return jsonify({
"response": [],
"message": e.args[0]["hint_message"]
}), 200
except Error as e:
return jsonify({"message": e.args[0]["hint_message"]}), 404
else:
objects = json_utility.me_obj_list_to_json_list(api_list.objects)
return jsonify({
"response": {
"objects": objects,
"count": api_list.count,
"page_no": api_list.page_no,
"page_size": api_list.page_size,
}
}), 200
def get_api_list():
"""
带搜索关键字的,
:return:
:rtype:
"""
user_ID = get_jwt_identity()
page_no = int(request.args.get('page_no', 1))
page_size = int(request.args.get('page_size', 5))
search_query = request.args.get('search_query', None)
default_max_score = float(request.args.get('max_score', 0.1))
try:
api_list = AppService.list_projects(
search_query=search_query,
page_no=page_no,
page_size=page_size,
default_max_score=default_max_score,
privacy=None,
user_ID=None)
except Warning as e:
return jsonify({
"response": [],
"message": e.args[0]["hint_message"]
}), 200
except Error as e:
return jsonify({"message": e.args[0]["hint_message"]}), 404
else:
objects = api_list.objects
for object in objects:
object.user_ID = object.user.user_ID
objects = json_utility.me_obj_list_to_json_list(objects)
return jsonify({
"response": {
"objects": objects,
"count": api_list.count,
"page_no": api_list.page_no,
"page_size": api_list.page_size
},
}), 200
def get():
channel = request.args.get("channel", 'all')
page_no = int(request.args.get('page_no', 1))
page_size = int(request.args.get('page_size', 50))
if channel == 'all':
query = {}
else:
query = {"channel": channel}
world_messages = WorldBusiness.get_pagination(
query=query,
page_no=page_no, page_size=page_size)
for message in world_messages.objects:
if hasattr(message, "sender") and message.sender:
message.sender_user_ID = message.sender.user_ID
else:
message.sender_user_ID = "system"
if world_messages:
return jsonify({
"response": {
"objects": json_utility.me_obj_list_to_json_list(world_messages.objects)
}
}), 200
def get_api_list():
"""
获取用户 自己使用过的apis，自己收藏的apis, 自己star的apis, 带搜索关键字的
:return:
:rtype:
"""
page_no = int(request.args.get('page_no', 1))
page_size = int(request.args.get('page_size', 5))
search_query = request.args.get('search_query', None)
get_type = request.args.get('get_type', ApiGetType.all)
user_ID = request.args.get('user_ID', None)
default_max_score = float(request.args.get('max_score', 0.4))
print("get_type", get_type)
try:
api_list = api_service.get_api_list(
get_type=get_type,
search_query=search_query,
user_ID=user_ID,
page_no=page_no,
page_size=page_size,
default_max_score=default_max_score)
except Warning as e:
return jsonify({
"response": [],
"message": e.args[0]["hint_message"]
}), 200
except Error as e:
return jsonify({"message": e.args[0]["hint_message"]}), 404
else:
if get_type == ApiGetType.chat:
api_list = json_utility.convert_to_json(api_list)
else:
api_list = json_utility.me_obj_list_to_json_list(api_list)
return jsonify({"response": api_list}), 200
def get_module_list():
module_list = module_business.get_all().order_by('-create_time')
module_list = json_utility.me_obj_list_to_json_list(module_list)
return jsonify({"response": module_list}), 200
def check_data_set_integrity(data_set_id):
data_objects = data_business.get_by_data_set(data_set_id)
# convert mongoengine objects to dicts
data_objects = json_utility.me_obj_list_to_json_list(data_objects)
data_fields = get_fields_with_types(data_set_id)
return check_data_integrity(data_objects, data_fields)
def get_trigger(cls, unit):
triggers = CourseUnitTriggerBusiness.read({'unit': unit})
return json_utility.me_obj_list_to_json_list(triggers), len(triggers)
