def term_view(term_id):
term = Term.query.get_or_404(term_id)
project = Projects.query.get_or_404(term.project_id)
##### РОЛЬ ДОСТУПА #####
# Смотрим роли пользователей по проекту
project_roles = get_roles(item_id=project.id, item_type=2)
# определяем роль пользователя
if current_user.is_authenticated:
curr_user_role = user_role(project_roles, current_user.id)
else:
curr_user_role = ''
# COURSES with pagination
per_page=10
page = request.args.get('page', 1, type=int)
description_html_dict = {}
tutors_html_dict = {}
courses = Courses.query.filter_by(term_id=term.id).order_by(Courses.start_date.desc()).paginate(page=page, per_page=per_page)
courses_whole = Courses.query.filter_by(term_id=term.id).order_by(Courses.start_date.desc())[page*per_page-per_page:page*per_page]
for course in courses_whole:
description_html_dict[course.id] = Markup(text_for_markup(course.description))
tutors_html_dict[course.id] = Markup(text_for_markup(course.tutors))
# разделяем преформатированный текст на строки, так как переносы не обрабатываются
description_html=Markup(text_for_markup(term.description))
return render_template('term.html',
term = term,
project = project,
curr_user_role = curr_user_role,
description = description_html,
date_translate=date_translate,
courses = courses,
courses_description = description_html_dict,
courses_tutors=tutors_html_dict)
def term_list(project_id):
'''
Показываем список периодов занятий в проекте (семестры, четверти, смены)
'''
project = Projects.query.get_or_404(project_id)
# Смотрим роли пользователей по проекту
project_roles = get_roles(item_id=project.id, item_type=2)
# определяем роль пользователя
if current_user.is_authenticated:
curr_user_role = user_role(project_roles, current_user.id)
else:
curr_user_role = ''
# print(f'curr user role: {curr_user_role}')
# pagination
# Максимальное количество элементов на странице
per_page=15
page = request.args.get('page', 1, type=int)
description_html_list_dict = {}
term_set = Term.query.filter_by(project_id=project.id).order_by(Term.start_date.desc()).paginate(page=page, per_page=per_page)
term_whole = Term.query.filter_by(project_id=project.id).order_by(Term.start_date.desc())[page*per_page-per_page:page*per_page]
for term in term_whole:
# description_html_list_dict[term.id] = text_format_for_html(term.description)
description_html_list_dict[term.id] = Markup(text_for_markup(term.description))
return render_template('projects_term.html',
description_dict=description_html_list_dict,
term_set=term_set,
project_name = project.name,
project_id = project.id,
project=project,
label_image = project.label_image,
curr_user_role = curr_user_role,
date_translate=date_translate)
def lesson_view(lesson_id):
lesson = Lessons.query.get_or_404(lesson_id)
course = Courses.query.get_or_404(lesson.course_id)
term = Term.query.get_or_404(course.term_id)
project = Projects.query.get_or_404(term.project_id)
quant_of_comments = count_comments(lesson.id, item_type=4)
##### РОЛЬ ДОСТУПА #####
# Смотрим роли пользователей по проекту
project_roles = get_roles(item_id=project.id, item_type=2)
# определяем роль пользователя
if current_user.is_authenticated:
curr_user_role = user_role(project_roles, current_user.id)
else:
curr_user_role = ''
if lesson.method_id:
method = Methodics.query.get_or_404(lesson.method_id)
else:
method=''
# разделяем преформатированный текст на строки, так как переносы не обрабатываются
description_html=Markup(text_for_markup(lesson.description))
tutors_html=Markup(text_for_markup(lesson.tutors))
web_links_html=Markup(text_for_links_markup(lesson.web_links))
note_html=Markup(text_for_markup(lesson.note))
# Формируем список с файлами презентаций, достаем из базы список в JSON и переводим его в нормальный
attachments = []
if lesson.attach:
for attachment in json.loads(lesson.attach):
attachments.append(attachment)
return render_template('lesson.html',
term = term,
project = project,
curr_user_role=curr_user_role,
course = course,
lesson=lesson,
method=method,
attachments = attachments,
description = description_html,
note = note_html,
web_links = web_links_html,
tutors = tutors_html,
quant_of_comments=quant_of_comments,
date_translate=date_translate)
def student_view(student_id):
# Получаем из базы всю инфу свзанную со студентом
student = Students.query.get_or_404(student_id)
student_proj_info_dict = student_projects_info_dict(student_id)
print(f'student_proj_info_dict:{student_proj_info_dict}')
##### РОЛЬ ДОСТУПА #####
# Проверяем есть ли у пользователя хоть в одном проекте участника права подходящие для просмотра
students_projects = student_proj_info_dict['students_projects']
# В форму отправляем просто флаг доступа к информации
allow_flag = False
for project in students_projects:
# Смотрим роли пользователей по проекту
project_roles = get_roles(item_id=project.id, item_type=2)
# определяем роль пользователя
curr_user_role = user_role(project_roles, current_user.id)
# завершаем обработку если у пользователя не хватает прав
if ((curr_user_role in ['admin', 'moder', 'reader'])
or (current_user.username == 'Administrator')
or (current_user.id == project.author_id)):
allow_flag = True
if not allow_flag and current_user.username != 'Administrator':
abort(403)
# разделяем преформатированный текст на строки, так как переносы не обрабатываются
address_html = Markup(text_for_markup(student.address))
note_html = Markup(text_for_markup(student.note))
# Формируем список с файлами презентаций, достаем из базы список в JSON и переводим его в нормальный
attachments = []
if student.attach:
for attachment in json.loads(student.attach):
attachments.append(attachment)
return render_template(
'student.html',
student=student,
students_group=student_proj_info_dict['students_group'],
students_courses=student_proj_info_dict['students_courses'],
students_terms=student_proj_info_dict['students_terms'],
students_projects=student_proj_info_dict['students_projects'],
attachments=attachments,
allow_flag=allow_flag,
address=address_html,
note=note_html,
date_translate=date_translate,
zip=zip)
def project_view(project_id):
# Получаем из базы метод, тайминг занятия, этапы занятия
project = Projects.query.get_or_404(project_id)
quant_of_comments = count_comments(project.id, item_type=2)
##### РОЛЬ ДОСТУПА #####
# Смотрим роли пользователей по проекту
project_roles = get_roles(item_id=project.id, item_type=2)
# определяем роль пользователя
if current_user.is_authenticated:
curr_user_role = user_role(project_roles, current_user.id)
else:
curr_user_role = ''
# разделяем преформатированный текст на строки, так как переносы не обрабатываются
description_html=Markup(project.description)
short_desc_html=Markup(text_for_markup(project.short_desc))
contacts_info_html=Markup(text_for_markup(project.contacts_info))
address_html=Markup(text_for_markup(project.address))
note_html=Markup(text_for_markup(project.note))
web_links_html=Markup(text_for_links_markup(project.web_links))
# Формируем список с файлами презентаций, достаем из базы список в JSON и переводим его в нормальный
attachments = []
if project.attach:
for attachment in json.loads(project.attach):
attachments.append(attachment)
return render_template('project.html',
project = project,
description=description_html,
short_desc=short_desc_html,
contacts_info = contacts_info_html,
address = address_html,
note = note_html,
web_links = web_links_html,
attachments = attachments,
curr_user_role = curr_user_role,
label_image=project.label_image,
date_translate=date_translate,
quant_of_comments=quant_of_comments)
def edit_timing(method_id):
"""
Редактируем и дополняем существующий тайминг для методики method_id
"""
timing = MethodTiming.query.filter_by(method_id=method_id).first()
method = Methodics.query.get_or_404(method_id)
# steps = TimingSteps.query.filter_by(method_timing_id=method.timing_id)
steps = db.session.query(TimingSteps).filter_by(
method_timing_id=timing.id).order_by('step_seq_number')
timing_left = time_left(steps, timing.duration)
##### РОЛЬ ДОСТУПА #####
# Смотрим роли пользователей по методике
method_roles = get_roles(item_id=method.id, item_type=1)
# определяем роль пользователя
curr_user_role = user_role(method_roles, current_user.id)
# завершаем обработку если у пользователя не хватает прав
if not ((curr_user_role in ['admin', 'moder']) or
(current_user.username == 'Administrator') or
(current_user == method.author)):
abort(403)
# print(steps)
form = AddTimingForm()
if form.validate_on_submit():
timing.duration = form.duration.data
db.session.commit()
return redirect(url_for('methodics.update', method_id=method.id))
elif request.method == 'GET':
form.duration.data = timing.duration
form.check_duration_data_type(form.duration)
steps_desc_dict = {}
steps_results_dict = {}
for step in steps:
steps_desc_dict[step.id] = Markup(step.step_desc)
steps_results_dict[step.id] = Markup(text_for_markup(step.step_result))
return render_template('update_timing.html',
form=form,
timing_id=timing.id,
method_author=method.author,
method_id=method.id,
method=method,
curr_user_role=curr_user_role,
steps=steps,
steps_desc_dict=steps_desc_dict,
steps_results_dict=steps_results_dict,
timing_left=timing_left)
def method(method_id):
# Получаем из базы метод, тайминг занятия, этапы занятия
method = Methodics.query.get_or_404(method_id)
timing = MethodTiming.query.filter_by(method_id=method_id).first()
steps = db.session.query(TimingSteps).filter_by(
method_timing_id=method.timing_id).order_by('id')
quant_of_comments = count_comments(method.id, item_type=1)
print(f'Система: {os.name}')
##### РОЛЬ ДОСТУПА #####
# Смотрим роли пользователей по проекту
method_roles = get_roles(item_id=method.id, item_type=1)
# определяем роль пользователя
if current_user.is_authenticated:
curr_user_role = user_role(method_roles, current_user.id)
else:
curr_user_role = ''
# разделяем преформатированный текст на строки, так как переносы не обрабатываются
description_html = Markup(method.description)
short_desc_html = Markup(text_for_markup(method.short_desc))
literature_html = Markup(text_for_markup(method.literature))
consumables_html = Markup(text_for_markup(method.consumables))
steps_desc_dict = {}
steps_results_dict = {}
for step in steps:
steps_desc_dict[step.id] = Markup(step.step_desc)
steps_results_dict[step.id] = Markup(text_for_markup(step.step_result))
# создание превьюшек картинок по указанным ссылкам
# получаем данные из формы, бъем их по строкам, делаем список из путей к превьюшкам и список с сылками
# затем делаем список кортежей с линком и путём к превьюшке, который отправляем в форму для отображения
if method.images:
image_html_links = text_format_for_html(method.images)
thumb_links = thumbnail_list(image_html_links, method.id)
images_list = img_tupal(image_html_links, thumb_links)
else:
images_list = []
# ссылки на музыку
if method.music:
music_list = text_format_for_html(method.music)
music_url_list = take_music_url(music_list)
else:
music_url_list = []
# формируем ссылку на видео
if method.video:
video_html_links = text_format_for_html(method.video)
print(video_html_links)
else:
video_html_links = []
# Проверяем наличие тайминга
timing = MethodTiming.query.filter_by(method_id=method_id).first()
if timing:
timing_duration = timing.duration
steps = db.session.query(TimingSteps).filter_by(
method_timing_id=timing.id).order_by('step_seq_number')
if len(list(steps)) == 0:
steps = None
else:
timing_duration = None
# Возраст участников
if method.age_from:
# age_list = method.age_range.split(':')
age_list = []
age_list.append(method.age_from)
age_list.append(method.age_till)
else:
age_list = []
# Название категории
category = Categories.query.get(method.category)
# Test for deleting
timing_id = db.session.execute(
text(f"select timing_id from methodics where id='{method_id}'")).first(
)[0]
print(f'Timing ID: {timing_id}')
# Формируем список с файлами презентаций, достаем из базы список в JSON и переводим его в нормальный
presentations = []
if method.presentation:
for presentation in json.loads(method.presentation):
presentations.append(presentation)
return render_template('method.html',
title=method.title,
date=method.publish_date,
description=description_html,
short_desc=short_desc_html,
presentations=presentations,
images_list=images_list,
music_list=music_url_list,
method_label_image=method.method_label_image,
method=method,
curr_user_role=curr_user_role,
videos=video_html_links,
literature=literature_html,
consumables=consumables_html,
date_translate=date_translate,
timing_duration=timing_duration,
steps=steps,
steps_desc_dict=steps_desc_dict,
steps_results_dict=steps_results_dict,
category=category.category_name,
age_list=age_list,
quant_of_comments=quant_of_comments)
def course_view(course_id):
course = Courses.query.get_or_404(course_id)
term = Term.query.get_or_404(course.term_id)
project = Projects.query.get_or_404(term.project_id)
quant_of_comments = count_comments(course.id, item_type=3)
course_schedule = Lessons.query.filter_by(course_id=course.id).order_by(Lessons.lesson_date).order_by(Lessons.start_time).all()
session['course_id'] = course.id
##### РОЛЬ ДОСТУПА #####
# Смотрим роли пользователей по проекту
project_roles = get_roles(item_id=project.id, item_type=2)
# определяем роль пользователя
if current_user.is_authenticated:
curr_user_role = user_role(project_roles, current_user.id)
else:
curr_user_role = ''
if course.students_group_id:
students_group = StudentsGroup.query.get(course.students_group_id)
student_group_desc=students_group.description
else:
student_group_desc=''
# разделяем преформатированный текст на строки, так как переносы не обрабатываются
description_html=Markup(text_for_markup(course.description))
contacts_info_html=Markup(text_for_markup(course.contacts_info))
address_html=Markup(text_for_markup(course.address))
tutors_html=Markup(text_for_markup(course.tutors))
web_links_html=Markup(text_for_links_markup(course.web_links))
note_html=Markup(text_for_markup(course.note))
# Формируем список с файлами презентаций, достаем из базы список в JSON и переводим его в нормальный
attachments = []
if course.attach:
for attachment in json.loads(course.attach):
attachments.append(attachment)
# формируем список группы
students_group_list = []
if course.students_group_id:
students_group = StudentsGroup.query.get_or_404(course.students_group_id)
learning_group = Learning_groups.query.filter_by(group_id=course.students_group_id)
for student in learning_group:
students_group_list.append(Students.query.filter_by(id=student.student_id).first())
# формируем словарь с привязанными к занятим методиками
methods_dict = {}
if course_schedule:
# students_group = StudentsGroup.query.get_or_404(course.students_group_id)
# learning_group = Learning_groups.query.filter_by(group_id=course.students_group_id)
for lesson in course_schedule:
method_id = lesson.method_id
method = Methodics.query.filter_by(id=method_id).first()
methods_dict[method_id] = method
return render_template('course.html',
term = term,
project = project,
curr_user_role=curr_user_role,
course = course,
course_schedule=course_schedule,
methods_dict=methods_dict,
attachments = attachments,
description = description_html,
contacts_info = contacts_info_html,
address = address_html,
note = note_html,
web_links = web_links_html,
tutors = tutors_html,
date_translate=date_translate,
students_group_desc=student_group_desc,
students_group_list=students_group_list,
quant_of_comments=quant_of_comments,
len=len,
zip=zip)