def course_add_window(request):
try:
def course_update_count(course, course_count):
course_count[
course] = 1 if course.course and course.course.visible else 0
for child in course.children:
if not child.visible:
continue
course_count[course] += course_update_count(
child, course_count)
return course_count[course]
frame = int(
request.params['frame']) if 'frame' in request.params else 0
course_raw = db_session.query(CourseRaw).filter(
CourseRaw.id == request.matchdict['course_id']).one()
course = db_session.query(Course).filter(Course.id == 1).one()
course_count = {}
course_update_count(course, course_count)
return {
'course': course,
'course_raw': course_raw,
'course_count': course_count,
'frame': frame,
}
except Exception as e:
return Response("Error: " + e.__str__())
def course_add_window(request):
try:
def course_update_count(course, course_count):
course_count[course] = 1 if course.course and course.course.visible else 0
for child in course.children:
if not child.visible:
continue
course_count[course] += course_update_count(child, course_count)
return course_count[course]
frame = int(request.params['frame']) if 'frame' in request.params else 0
course_raw = db_session.query(CourseRaw).filter(
CourseRaw.id == request.matchdict['course_id']
).one()
course = db_session.query(Course).filter(Course.id == 1).one()
course_count = {}
course_update_count(course, course_count)
return {
'course': course,
'course_raw': course_raw,
'course_count': course_count,
'frame': frame,
}
except Exception as e:
return Response("Error: " + e.__str__())
def course_my_categories(request):
try:
frame = int(request.params.get('frame', 1))
course_root = db_session.query(Course).filter(Course.id == 1).one()
course_list = []
make_course_list(course_root, course_list, 0)
my_nodes = db_session.query(Course).filter(
Course.id != 1,
Course.course_id == 0,
Course.author == RequestGetUserId(request),
).order_by(Course.verified).all()
my_verified_nodes = [node for node in my_nodes if node.verified]
my_unverified_nodes = [node for node in my_nodes if not node.verified]
root_nodes = course_tree_get_root_nodes(RequestGetUserId(request))
'''
my_nodes = [node for node in my_nodes if node in root_nodes] + \
[node for node in my_nodes if node not in root_nodes]
'''
return {
'frame': frame,
'course_list': course_list,
'my_nodes': my_nodes,
'my_unverified_nodes': my_unverified_nodes,
'root_nodes': root_nodes,
'default_storage': json.dumps({}),
'GetNodeUsers': GetNodeUsers,
}
except Exception as e:
return Response("Error: " + e.__str__())
def course_my_categories(request):
try:
frame = int(request.params.get('frame', 1))
course_root = db_session.query(Course).filter(Course.id == 1).one()
course_list = []
make_course_list(course_root, course_list, 0)
my_nodes = db_session.query(Course).filter(
Course.id != 1,
Course.course_id == 0,
Course.author == RequestGetUserId(request),
).order_by(Course.verified).all()
my_verified_nodes = [node for node in my_nodes if node.verified]
my_unverified_nodes = [node for node in my_nodes if not node.verified]
root_nodes = course_tree_get_root_nodes(RequestGetUserId(request))
'''
my_nodes = [node for node in my_nodes if node in root_nodes] + \
[node for node in my_nodes if node not in root_nodes]
'''
return {
'frame': frame,
'course_list': course_list,
'my_nodes': my_nodes,
'my_unverified_nodes': my_unverified_nodes,
'root_nodes': root_nodes,
'default_storage': json.dumps({}),
'GetNodeUsers': GetNodeUsers,
}
except Exception as e:
return Response("Error: " + e.__str__())
def course_tree_get_root_nodes(user_id):
user_id = int(user_id)
caps = db_session.query(CourseTreeCap).filter(
CourseTreeCap.user_id == user_id, ).all()
root_nodes = db_session.query(Course).filter(
Course.id.in_([cap.node_id for cap in caps]), )
return root_nodes
def course_dump(request):
try:
def course_update_count(course, course_count, show_hidden, childrenMap):
course_count[course] = 1 if course.course and (show_hidden or course.course.visible) else 0
children = get_children_by_map(childrenMap, course.id)
for child in children:
if not show_hidden and not child.visible:
continue
course_count[course] += course_update_count(child, course_count, show_hidden, childrenMap)
return course_count[course]
dump = request.params['dump'] if 'dump' in request.params else 0
show_hidden = request.params['show_hidden'] if 'show_hidden' in request.params else 0
course_root = db_session.query(Course).filter(Course.id == request.matchdict['course_id']).one()
displayed_courses = db_session.query(Course).filter(Course.displayed == 1).all()
course_count = {}
courses = db_session.query(Course).order_by(
Course.parent_id,
Course.order,
).all()
childrenMap = {}
for course in courses:
if not course.parent_id in childrenMap:
childrenMap[course.parent_id] = []
childrenMap[course.parent_id].append(course)
course_update_count(course_root, course_count, show_hidden, childrenMap)
default_storage = json.dumps({
"#region{0}".format(course_root.id): int(course_root.displayed) \
for course_root in displayed_courses
})
if dump:
filename = "course_dump" + ("_show_hidden" if show_hidden else "") + ".php"
filepath = request.registry.settings['source_tree.course.dump_path'] + filename
dump_file = open(filepath, "w", encoding="utf-8")
dump_file.write(Template(filename=request.registry.settings["source_tree.project_path"] \
+ "/source_tree/templates/course_dump.mak", input_encoding="utf-8").render_unicode(
course_root=course_root,
show_hidden=show_hidden,
dump=dump,
course_count=course_count,
default_storage=default_storage,
childrenMap=childrenMap,
get_children_by_map=get_children_by_map,
))
dump_file.close()
return Response("ok. dumped to {0}".format(filepath))
else:
return {
'course_root': course_root,
'show_hidden': show_hidden,
'dump': dump,
'course_count': course_count,
'default_storage': default_storage,
'childrenMap': childrenMap,
'get_children_by_map': get_children_by_map,
}
except Exception as e:
return Response("Error: " + e.__str__())
def course_tree_get_root_nodes(user_id):
user_id = int(user_id)
caps = db_session.query(CourseTreeCap).filter(
CourseTreeCap.user_id == user_id,
).all()
root_nodes = db_session.query(Course).filter(
Course.id.in_([cap.node_id for cap in caps]),
)
return root_nodes
def course_add(request):
try:
add_dict = dict(request.params)
names = request.params['name'].split('\n')
order = request.params['order']
parent_id = int(request.params['parent_id'])
user_id = int(RequestGetUserId(request))
if order == 'end':
parent = db_session.query(Course).filter(
Course.id == request.params['parent_id']).one()
max_order = max(course.order for course in parent.children) \
if list(parent.children) else 0
order = "{0}:{1}".format(max_order, max_order + 10**7)
order, order_right = map(int, order.split(':'))
order_shift = (order_right - order) / (len(names) + 1)
ids = []
for name in names:
vals = name.split("+++")
title, course_id = name, 0
if len(vals) == 2:
title, course_id = vals
similar = db_session.query(Course).filter(
Course.parent_id == request.params['parent_id'],
Course.course_id == course_id,
).all()
verified = check_capability_ex_course(request, 'admin') \
or bool(course_tree_check_owner(parent_id, user_id))
if course_id:
if similar:
continue
if course_check_owner(int(course_id),
int(RequestGetUserId(request))):
check_capability_course(request, 'teacher')
else:
check_capability_course(request, 'admin')
else:
check_capability_course(request, 'teacher')
order += order_shift
add_dict['name'] = title
add_dict['order'] = order
add_dict['verified'] = verified
add_dict['course_id'] = course_id
add_dict['author'] = max(0, user_id)
node_id = course_add_by_dict(add_dict)
ids.append(node_id)
db_session.commit()
course_make_dump(request)
return {
"result": "ok",
"content": {
"new_id": ids,
}
}
except Exception as e:
return {"result": "error", "content": e.__str__()}
def course_tree_check_owner(node_id, user_id):
node_id = int(node_id)
user_id = int(user_id)
node = db_session.query(Course).filter(Course.id == node_id).one()
cap = db_session.query(CourseTreeCap).filter(
CourseTreeCap.node_id.in_(node.parents()),
CourseTreeCap.user_id == user_id,
).all()
acc_node = db_session.query(Course).filter(Course.id == cap[0].node_id).one() \
if cap else None
return acc_node
def course_tree_check_owner(node_id, user_id):
node_id = int(node_id)
user_id = int(user_id)
node = db_session.query(Course).filter(Course.id == node_id).one()
cap = db_session.query(CourseTreeCap).filter(
CourseTreeCap.node_id.in_(node.parents()),
CourseTreeCap.user_id == user_id,
).all()
acc_node = db_session.query(Course).filter(Course.id == cap[0].node_id).one() \
if cap else None
return acc_node
def GetNodeUsers(nodeId):
node = db_session.query(Course).filter(Course.id == nodeId).one()
parents = node.parents()
users = []
for parentNodeId in parents:
caps = db_session.query(CourseTreeCap).filter(
CourseTreeCap.node_id == parentNodeId, ).all()
currentUsers = db_session.query(User).filter(
User.id.in_([cap.user_id for cap in caps]), ).all()
users += currentUsers
users = list(set(users))
return users
def course_add(request):
try:
add_dict = dict(request.params)
names = request.params['name'].split('\n')
order = request.params['order']
parent_id = int(request.params['parent_id'])
user_id = int(RequestGetUserId(request))
if order == 'end':
parent = db_session.query(Course).filter(
Course.id == request.params['parent_id']
).one()
max_order = max(course.order for course in parent.children) \
if list(parent.children) else 0
order = "{0}:{1}".format(max_order, max_order + 10**7)
order, order_right = map(int, order.split(':'))
order_shift = (order_right - order) / (len(names) + 1)
ids = []
for name in names:
vals = name.split("+++")
title, course_id = name, 0
if len(vals) == 2:
title, course_id = vals
similar = db_session.query(Course).filter(
Course.parent_id == request.params['parent_id'],
Course.course_id == course_id,
).all()
verified = check_capability_ex_course(request, 'admin') \
or bool(course_tree_check_owner(parent_id, user_id))
if course_id:
if similar:
continue
if course_check_owner(int(course_id), int(RequestGetUserId(request))):
check_capability_course(request, 'teacher')
else:
check_capability_course(request, 'admin')
else:
check_capability_course(request, 'teacher')
order += order_shift
add_dict['name'] = title
add_dict['order'] = order
add_dict['verified'] = verified
add_dict['course_id'] = course_id
add_dict['author'] = max(0, user_id)
node_id = course_add_by_dict(add_dict)
ids.append(node_id)
db_session.commit()
course_make_dump(request)
return {"result": "ok", "content": {
"new_id": ids,
}}
except Exception as e:
return {"result": "error", "content": e.__str__()}
def course_get_not_in_list(request):
try:
course_nodes = db_session.query(Course).all()
used_courses = [course_node.course_id for course_node in course_nodes \
if course_node.course_id]
courses = db_session.query(CourseRaw).filter(
CourseRaw.category.in_([24, 34]),
not_(CourseRaw.id.in_(used_courses)),
).all()
return {
'courses': courses,
}
except Exception as e:
return Response("Error: " + str(e))
def GetNodeUsers(nodeId):
node = db_session.query(Course).filter(Course.id == nodeId).one()
parents = node.parents()
users = []
for parentNodeId in parents:
caps = db_session.query(CourseTreeCap).filter(
CourseTreeCap.node_id == parentNodeId,
).all()
currentUsers = db_session.query(User).filter(
User.id.in_([cap.user_id for cap in caps]),
).all()
users += currentUsers
users = list(set(users))
return users
def course_get_by_user(user_id):
user_id = int(user_id)
if user_id < 0:
return []
contextlevel = 50
role = db_session.query(Role).filter(Role.shortname == 'editingteacher').one()
role_assignments = db_session.query(RoleAssignment).filter(
RoleAssignment.userid == user_id,
RoleAssignment.roleid == role.id,
).all()
courses_id = [item.context.instanceid for item in role_assignments \
if item.context.contextlevel == contextlevel]
courses = db_session.query(CourseRaw).filter(CourseRaw.id.in_(courses_id)).all()
return courses
def course_check_owner(course_id, user_id):
if user_id < 0:
return False
contextlevel = 50
role = db_session.query(Role).filter(Role.shortname == 'editingteacher').one()
role_assignments = db_session.query(RoleAssignment).filter(
RoleAssignment.userid == user_id,
RoleAssignment.roleid == role.id,
).all()
for role_assignment in role_assignments:
if role_assignment.context.contextlevel == contextlevel\
and role_assignment.context.instanceid == course_id:
return True
return False
def course_get_not_in_list(request):
try:
course_nodes = db_session.query(Course).all()
used_courses = [course_node.course_id for course_node in course_nodes \
if course_node.course_id]
courses = db_session.query(CourseRaw).filter(
CourseRaw.category.in_([24, 34]),
not_(CourseRaw.id.in_(used_courses)),
).all()
return {
'courses': courses,
}
except Exception as e:
return Response("Error: " + str(e))
def course_check_owner(course_id, user_id):
if user_id < 0:
return False
contextlevel = 50
role = db_session.query(Role).filter(
Role.shortname == 'editingteacher').one()
role_assignments = db_session.query(RoleAssignment).filter(
RoleAssignment.userid == user_id,
RoleAssignment.roleid == role.id,
).all()
for role_assignment in role_assignments:
if role_assignment.context.contextlevel == contextlevel\
and role_assignment.context.instanceid == course_id:
return True
return False
def course_get_all_to_verify(request):
categories = int(request.params.get('categories', 0))
nodes_filter = db_session.query(Course).filter(Course.verified == False)
if categories:
nodes_filter = nodes_filter.filter(Course.course_id == 0)
else:
nodes_filter = nodes_filter.filter(Course.course_id > 0)
nodes = nodes_filter.order_by(Course.time).all()
result = []
for node in nodes:
res_item = {
'node': node,
'parent': node.parent,
}
if node.course:
res_item.update({
'course': {
'id': node.course.id,
'name': node.course.fullname
},
})
if node.user:
res_item.update({
'user': {
'id': node.user.id,
'firstname': node.user.firstname,
'lastname': node.user.lastname
}
})
result.append(res_item)
return result
def course_get_by_user(user_id):
user_id = int(user_id)
if user_id < 0:
return []
contextlevel = 50
role = db_session.query(Role).filter(
Role.shortname == 'editingteacher').one()
role_assignments = db_session.query(RoleAssignment).filter(
RoleAssignment.userid == user_id,
RoleAssignment.roleid == role.id,
).all()
courses_id = [item.context.instanceid for item in role_assignments \
if item.context.contextlevel == contextlevel]
courses = db_session.query(CourseRaw).filter(
CourseRaw.id.in_(courses_id)).all()
return courses
def contest_add_source(request):
try:
check_capability(request, 'admin')
statement_id = request.matchdict['contest_id']
source_id = request.matchdict['source_id']
statement_problems = db_session.query(StatementProblem).filter(
StatementProblem.statement_id == statement_id).order_by(
StatementProblem.rank).all()
for i in range(len(statement_problems)):
letter = ''
cur = i + 1
while cur:
cur -= 1
letter = chr(ord('A') + cur % 26) + letter
cur //= 26
source_add_by_dict({
'name': 'Задача ' + letter,
'parent_id': source_id,
'order': (i + 1) * 10**7,
'author': RequestGetUserId(request),
'verified': True,
'problem_id': statement_problems[i].problem_id
})
db_session.commit()
return {"result": "ok"}
except Exception as e:
return {"result": "error", "content": e.__str__()}
def problem_add_source(request):
try:
check_capability(request, 'user')
problem_id = request.matchdict['problem_id']
subject_id = request.matchdict['subject_id']
problem = problem_get_by_id(problem_id)
subject = source_get_by_id(subject_id)
if subject.get_type() != '_subject':
check_capability(request, 'admin')
cur_subject = db_session.query(Source).filter(
Source.parent_id == subject_id,
Source.problem_id == problem_id).all()
if cur_subject:
raise Exception('Already exists')
verified = check_capability_ex(request, 'edit')
add_dict = {
'name': problem.name,
'parent_id': subject_id,
'order': 0,
'problem_id': problem_id,
'author': RequestGetUserId(request),
'verified': verified
}
source_add_by_dict(add_dict)
db_session.commit()
return {'result': 'ok', 'verified': verified}
except Exception as e:
return {'result': 'error', 'content': e.__str__()}
def problem_add_source(request):
try:
check_capability(request, 'user')
problem_id = request.matchdict['problem_id']
subject_id = request.matchdict['subject_id']
problem = problem_get_by_id(problem_id)
subject = source_get_by_id(subject_id)
if subject.get_type() != '_subject':
check_capability(request, 'admin')
cur_subject = db_session.query(Source).filter(Source.parent_id == subject_id, Source.problem_id == problem_id).all()
if cur_subject:
raise Exception('Already exists')
verified = check_capability_ex(request, 'edit')
add_dict = {
'name': problem.name,
'parent_id': subject_id,
'order': 0,
'problem_id': problem_id,
'author': RequestGetUserId(request),
'verified': verified
}
source_add_by_dict(add_dict)
db_session.commit()
return {'result': 'ok', 'verified': verified}
except Exception as e:
return {'result': 'error', 'content': e.__str__()}
def source_get_all(request):
source_type = '_' + request.matchdict['source_type']
root = db_session.query(Source).filter(
Source.parent_id == 1,
Source.name == source_type
).one()
return source_get_all_by_node(root)
def contest_add_source(request):
try:
check_capability(request, 'admin')
statement_id = request.matchdict['contest_id']
source_id = request.matchdict['source_id']
statement_problems = db_session.query(StatementProblem).filter(
StatementProblem.statement_id == statement_id).order_by(StatementProblem.rank).all()
for i in range(len(statement_problems)):
letter = ''
cur = i + 1
while cur:
cur -= 1
letter = chr(ord('A') + cur % 26) + letter
cur //= 26
source_add_by_dict({
'name': 'Задача ' + letter,
'parent_id': source_id,
'order': (i + 1) * 10**7,
'author': RequestGetUserId(request),
'verified': True,
'problem_id': statement_problems[i].problem_id
})
db_session.commit()
return {"result": "ok"}
except Exception as e:
return {"result": "error", "content": e.__str__()}
def course_get_by_author(request):
try:
courses = course_get_by_user(request.matchdict['author_id'])
result = []
for course in courses:
nodes = db_session.query(Course).filter(
Course.course_id == course.id).all()
paths = [node.parent.full_name() + ("" if node.verified \
else " (не разобрано)") for node in nodes]
result.append({
'id': course.id,
'name': course.fullname,
'paths': paths,
'visible': course.visible,
'has_password': course.password != '',
})
return {
'result': 'ok',
'courses': result,
}
except Exception as e:
return {
'result': 'error',
'content': e.__str__(),
}
def course_get_all_to_verify(request):
categories = int(request.params.get('categories', 0))
nodes_filter = db_session.query(Course).filter(Course.verified == False)
if categories:
nodes_filter = nodes_filter.filter(Course.course_id == 0)
else:
nodes_filter = nodes_filter.filter(Course.course_id > 0)
nodes = nodes_filter.order_by(Course.time).all()
result = []
for node in nodes:
res_item = {
'node': node,
'parent': node.parent,
}
if node.course:
res_item.update({
'course': {
'id': node.course.id,
'name': node.course.fullname
},
})
if node.user:
res_item.update({
'user': {
'id': node.user.id,
'firstname': node.user.firstname,
'lastname': node.user.lastname
}
})
result.append(res_item)
return result
def course_get_users(course_id):
course_id = int(course_id)
contextlevel = 50
role = db_session.query(Role).filter(Role.shortname == 'editingteacher').one()
contexts = db_session.query(Context).filter(
Context.contextlevel == contextlevel,
Context.instanceid == course_id,
).all()
contexts_id = [item.id for item in contexts]
role_assignments = db_session.query(RoleAssignment).filter(
RoleAssignment.roleid == role.id,
RoleAssignment.contextid.in_(contexts_id),
).all()
users_id = [item.userid for item in role_assignments]
users = db_session.query(User).filter(User.id.in_(users_id)).all()
return users
def course_get_users(course_id):
course_id = int(course_id)
contextlevel = 50
role = db_session.query(Role).filter(
Role.shortname == 'editingteacher').one()
contexts = db_session.query(Context).filter(
Context.contextlevel == contextlevel,
Context.instanceid == course_id,
).all()
contexts_id = [item.id for item in contexts]
role_assignments = db_session.query(RoleAssignment).filter(
RoleAssignment.roleid == role.id,
RoleAssignment.contextid.in_(contexts_id),
).all()
users_id = [item.userid for item in role_assignments]
users = db_session.query(User).filter(User.id.in_(users_id)).all()
return users
def course_tree_get_user_nodes(user_id):
user_id = int(user_id)
caps = db_session.query(CourseTreeCap).filter(
CourseTreeCap.user_id == user_id, ).all()
nodes = set()
for cap in caps:
node = db_session.query(Course).filter(
Course.id == cap.node_id, ).one()
nodes |= set(item for item in node.get_subtree_nodes()
if not item.course_id)
authored_nodes = db_session.query(Course).filter(
Course.course_id == 0,
Course.author == user_id,
).all()
nodes |= set(authored_nodes)
ordered_nodes = sorted(list(nodes), key=lambda course: course.id)
return ordered_nodes
def course_tree_get_user_nodes(user_id):
user_id = int(user_id)
caps = db_session.query(CourseTreeCap).filter(
CourseTreeCap.user_id == user_id,
).all()
nodes = set()
for cap in caps:
node = db_session.query(Course).filter(
Course.id == cap.node_id,
).one()
nodes |= set(item for item in node.get_subtree_nodes() if not item.course_id)
authored_nodes = db_session.query(Course).filter(
Course.course_id == 0,
Course.author == user_id,
).all()
nodes |= set(authored_nodes)
ordered_nodes = sorted(list(nodes), key=lambda course: course.id)
return ordered_nodes
def problem_get_source_to_verify(request):
problem_id = request.matchdict['problem_id']
source_type = '_' + request.matchdict['source_type']
subjects_problem = db_session.query(Source).filter(Source.problem_id == problem_id).all()
subjects_problem = [{
'parent': source.parent,
'source': source
} for source in subjects_problem if source.get_type() == source_type and not source.verified]
return subjects_problem
def course_get_for_select(request):
try:
course_root = db_session.query(Course).filter(Course.id == 1).one()
course_list = []
make_course_list(course_root, course_list, 0)
return {
'course_list': course_list,
}
except Exception as e:
return Response("Error: " + e.__str__())
def course_get_nodes(request):
try:
nodes = db_session.query(Course).\
filter(Course.course_id == request.matchdict['course_id']).all()
return {
'result': 'ok',
'nodes': nodes,
}
except Exception as e:
return {'result': 'error', 'content': e.__str__()}
def problem_get_source_html(request):
problem_id = request.matchdict['problem_id']
source_type = request.matchdict['source_type']
sources = db_session.query(Source).filter(Source.problem_id == problem_id,
Source.verified).all()
source_list = []
for source in sources:
if source.get_type() == '_' + source_type:
source_list.append(source.get_path())
return {'source_list': source_list, 'source_type': source_type}
def course_adm(request):
try:
course_id = request.params['course_id'] if 'course_id' in request.params else None
course = db_session.query(CourseRaw).filter(CourseRaw.id == course_id).one() \
if course_id else None
return {
'course': course,
}
except Exception as e:
return Response("Error: " + e.__str__())
def course_get_for_select(request):
try:
course_root = db_session.query(Course).filter(Course.id == 1).one()
course_list = []
make_course_list(course_root, course_list, 0)
return {
'course_list': course_list,
}
except Exception as e:
return Response("Error: " + e.__str__())
def course_get_nodes(request):
try:
nodes = db_session.query(Course).\
filter(Course.course_id == request.matchdict['course_id']).all()
return {
'result': 'ok',
'nodes': nodes,
}
except Exception as e:
return {'result': 'error', 'content': e.__str__()}
def source_get_all_by_node(source, sources=None):
if not sources:
sources = []
children = db_session.query(Source).filter(
Source.parent_id == source.id,
Source.problem_id == 0).order_by(Source.order, Source.name).all()
for child in children:
sources.append(child)
source_get_all_by_node(child, sources)
return sources
def problem_get_source(request):
problem_id = request.matchdict['problem_id']
source_type = '_' + request.matchdict['source_type']
subjects_problem = db_session.query(Source).filter(Source.problem_id == problem_id).all()
subjects_problem = [{
'parent': source.parent,
'source': source,
'path': ', '.join(source.get_source_path()[2:])
} for source in subjects_problem if source.get_type() == source_type and source.verified]
return subjects_problem
def course_all(request):
try:
check_capability_course(request, 'admin')
courses_res = []
courses = db_session.query(CourseRaw).\
filter(CourseRaw.category.in_([24, 34])).all()
for course in courses:
nodes = db_session.query(Course).filter(Course.course_id == course.id).all()
paths = [node.parent.full_name() + ("" if node.verified else " (не разобрано)") \
for node in nodes]
courses_res.append({
'course': course,
'paths': paths,
'authors': course_get_users(course.id),
})
return {
'courses': courses_res,
}
except Exception as e:
return Response("Error: " + e.__str__())
def source_get_all_by_node(source, sources = None):
if not sources:
sources = []
children = db_session.query(Source).filter(
Source.parent_id == source.id,
Source.problem_id == 0
).order_by(Source.order, Source.name).all()
for child in children:
sources.append(child)
source_get_all_by_node(child, sources)
return sources
def problem_get_source_html(request):
problem_id = request.matchdict['problem_id']
source_type = request.matchdict['source_type']
sources = db_session.query(Source).filter(Source.problem_id == problem_id, Source.verified).all()
source_list = []
for source in sources:
if source.get_type() == '_' + source_type:
source_list.append(source.get_path())
return {
'source_list': source_list,
'source_type': source_type
}
def problem_get_source(request):
problem_id = request.matchdict['problem_id']
source_type = '_' + request.matchdict['source_type']
subjects_problem = db_session.query(Source).filter(
Source.problem_id == problem_id).all()
subjects_problem = [{
'parent': source.parent,
'source': source,
'path': ', '.join(source.get_source_path()[2:])
} for source in subjects_problem
if source.get_type() == source_type and source.verified
]
return subjects_problem
def problem_get_source_to_verify(request):
problem_id = request.matchdict['problem_id']
source_type = '_' + request.matchdict['source_type']
subjects_problem = db_session.query(Source).filter(
Source.problem_id == problem_id).all()
subjects_problem = [
{
'parent': source.parent,
'source': source
} for source in subjects_problem
if source.get_type() == source_type and not source.verified
]
return subjects_problem
def source_dir_contest_get_problems(request):
try:
basket = request.session['basket']
problems = [db_session.query(Problem).filter(Problem.id == id).one()
for id in basket.problems]
return {
"result": "ok",
"problems": [{
"id": problem.id,
"name": problem.name
} for problem in problems]
}
except Exception as e:
return {"result": "error", "content": e.__str__()}
def source_get_all_to_verify(request):
source_type = '_' + request.matchdict['source_type']
sources = db_session.query(Source).filter(Source.verified == False).order_by(Source.time).all()
sources = [{
'source': source,
'parent': source.parent,
'problem': {
'id': source.problem.id,
'name': source.problem.name
},
'user': {
'id': source.user.id,
'firstname': source.user.firstname,
'lastname': source.user.lastname
}
} for source in sources if source.get_type() == source_type]
return sources
def source_dir_contest_get_problems(request):
try:
basket = request.session['basket']
problems = [
db_session.query(Problem).filter(Problem.id == id).one()
for id in basket.problems
]
return {
"result":
"ok",
"problems": [{
"id": problem.id,
"name": problem.name
} for problem in problems]
}
except Exception as e:
return {"result": "error", "content": e.__str__()}
def source_get_all_to_verify(request):
source_type = '_' + request.matchdict['source_type']
sources = db_session.query(Source).filter(
Source.verified == False).order_by(Source.time).all()
sources = [{
'source': source,
'parent': source.parent,
'problem': {
'id': source.problem.id,
'name': source.problem.name
},
'user': {
'id': source.user.id,
'firstname': source.user.firstname,
'lastname': source.user.lastname
}
} for source in sources if source.get_type() == source_type]
return sources
def course_get_by_author(request):
try:
courses = course_get_by_user(request.matchdict['author_id'])
result = []
for course in courses:
nodes = db_session.query(Course).filter(Course.course_id == course.id).all()
paths = [node.parent.full_name() + ("" if node.verified \
else " (не разобрано)") for node in nodes]
result.append({
'id': course.id,
'name': course.fullname,
'paths': paths,
'visible': course.visible,
'has_password': course.password != '',
})
return {
'result': 'ok',
'courses': result,
}
except Exception as e:
return {
'result': 'error',
'content': e.__str__(),
}
def source_get_root(source_type):
return db_session.query(Source).filter(
Source.parent_id == 1, Source.name == '_' + source_type).one()
def source_get_children_without_problems(source):
return db_session.query(Source).filter(Source.parent_id == source.id,
Source.problem_id == 0).order_by(
Source.order,
Source.name).all()
def source_get_root(source_type):
return db_session.query(Source).filter(
Source.parent_id == 1,
Source.name == '_' + source_type
).one()
def source_get_by_id(source_id):
return db_session.query(Source).filter(Source.id == source_id).one()
def problem_get_by_id(problem_id):
return db_session.query(Problem).filter(Problem.id == problem_id).one()
def course_get_by_id(course_id):
return db_session.query(Course).filter(
Course.id == course_id
).one()
