def add_student_to_list(course_id, student_id):
course = Courses.query.get_or_404(course_id)
term = term = Term.query.get_or_404(course.term_id)
project = Projects.query.get_or_404(term.project_id)
group_id = course.students_group_id
##### РОЛЬ ДОСТУПА #####
# Смотрим роли пользователей по проекту
project_roles = get_roles(item_id=project.id, item_type=2)
# определяем роль пользователя
curr_user_role = user_role(project_roles, current_user.id)
# завершаем обработку если у пользователя не хватает прав
if not ((curr_user_role in ['admin', 'moder']) or
(current_user.username == 'Administrator') or
(current_user.id == project.author_id)):
abort(403)
if Learning_groups.query.filter_by(group_id=group_id,
student_id=student_id).all():
flash(
'Выбранный участник уже итак в списке. Для добавления выберите кого-то другого.',
'negative')
return redirect(
url_for('students.update_students_group_list',
course_id=course.id))
add_to_group = Learning_groups(group_id=group_id,
student_id=student_id,
course_id=course.id,
term_id=term.id,
project_id=project.id)
db.session.add(add_to_group)
db.session.commit()
return redirect(
url_for('students.update_students_group_list', course_id=course.id))
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 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 delete_project(project_id):
project = Projects.query.get_or_404(project_id)
##### РОЛЬ ДОСТУПА #####
# Смотрим роли пользователей по проекту
project_roles = get_roles(item_id=project.id, item_type=2)
# определяем роль пользователя
curr_user_role = user_role(project_roles, current_user.id)
# завершаем обработку если у пользователя не хватает прав
if not ((curr_user_role in ['admin'])
or (current_user.username == 'Administrator')
or (current_user.id == project.author_id)):
abort(403)
# Удаляем заглавную картинку для проекта
if project.label_image != 'default_project.png':
del_project_ava = os.path.join(current_app.root_path, os.path.join('static', 'projects_pics', 'project_ava', project.label_image))
os.remove(del_project_ava)
# Удаляем прикрепленные файлы
if project.attach:
for attachment in json.loads(project.attach):
filename = attachment
curr_folder_path = os.path.join('static', 'project_attachments')
directory = os.path.join(current_app.root_path, curr_folder_path, 'project_'+str(project_id))
shutil.rmtree(directory, ignore_errors=True)
# Удалние проекта, после того как разобрались с констреинтами
db.session.delete(project)
db.session.commit()
flash('Проект удален', 'success')
return redirect(url_for('projects.projects_list'))
def delete_term(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)
# определяем роль пользователя
curr_user_role = user_role(project_roles, current_user.id)
# завершаем обработку если у пользователя не хватает прав
if not ((curr_user_role in ['admin'])
or (current_user.username == 'Administrator')
or (current_user.id == project.author_id)):
abort(403)
# Формируем список модераторов
moder_stat = False
if project.moders_list:
moders_list = text_format_for_html(project.moders_list)
if current_user.id in moders_list:
moder_stat = True
if ((project.author_id != current_user) and (current_user.username != 'Administrator') and not moder_stat):
abort(403)
# Удаляем заглавную картинку для проекта
if term.label_image != 'default_term.png':
del_project_term = os.path.join(current_app.root_path, os.path.join('static', 'projects_pics', 'project_term', term.label_image))
os.remove(del_project_term)
# Удалние проекта, после того как разобрались с констреинтами
db.session.delete(term)
db.session.commit()
flash('Период проект удален', 'success')
return redirect(url_for('projects.term_list', project_id=project.id))
def add_timing(method_id):
"""
Создаем новый тайминг для методики method_id
"""
method = Methodics.query.get_or_404(method_id)
##### РОЛЬ ДОСТУПА #####
# Смотрим роли пользователей по методике
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)
form = AddTimingForm()
if form.validate_on_submit():
timing = MethodTiming(method_id=method_id, duration=form.duration.data)
db.session.add(timing)
db.session.commit()
timing = MethodTiming.query.filter_by(method_id=method_id).first()
method.timing_id = timing.id
db.session.commit()
return redirect(url_for('timing.edit_timing', method_id=method_id))
return render_template('add_timing.html', form=form, method_id=method_id)
def update_term(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)
# определяем роль пользователя
curr_user_role = user_role(project_roles, current_user.id)
# завершаем обработку если у пользователя не хватает прав
if not ((curr_user_role in ['admin', 'moder'])
or (current_user.username == 'Administrator')
or (current_user.id == project.author_id)):
abort(403)
form = UpdateTermForm()
if form.validate_on_submit():
# Если загружается картинка для Периода
print(f'Новая каритнка: {form.label_image.data}')
if form.label_image.data:
project_id = term.project_id
pic = add_term_pic(form.label_image.data, term_id, term.label_image)
term.label_image = pic
term.name = form.name.data
term.description = form.description.data
term.start_date = form.start_date.data
term.finish_date = form.finish_date.data
db.session.commit()
return redirect(url_for('projects.term_view', term_id=term.id))
# первоначальная загрузка
elif request.method == 'GET':
form.name.data = term.name
form.description.data = term.description
form.start_date.data = term.start_date
form.finish_date.data = term.finish_date
label_image = url_for('static', filename = 'projects_pics/project_term/'+term.label_image)
# Если форма заполненна с ошибками, а валидаторам плевать
if form.errors:
flash_text = 'Форма методики заполнена неверно. <br>'
for error in form.errors:
flash_text += form.errors[error][0]
flash_text += 'К сожалению, последние изменения не сохранены. '
flash(Markup(flash_text), 'negative')
return render_template('update_term.html',
label_image=label_image,
project_name = project.name,
project=project,
curr_user_role = curr_user_role,
form=form)
def delete_attachment(student_id):
"""
Удаляем прикрепленный файл для выбранного участника
"""
student = Students.query.get_or_404(student_id)
student_proj_info_dict = student_projects_info_dict(student_id)
##### РОЛЬ ДОСТУПА #####
# Проверяем есть ли у пользователя хоть в одном проекте права подходящие для просмотра участников
user_projects_roles = UserRole.query.filter(
UserRole.item_type == 2, UserRole.user_id == current_user.id).all()
users_projects = list(users_project.item_id
for users_project in user_projects_roles)
# созданные пользователем проекты
created_projects = Projects.query.filter(
Projects.author_id == current_user.id).all()
for project in created_projects:
# список с номерами всех проектов
users_projects.append(project.id)
allow_flag = False
projects_list = []
for project_id in users_projects:
projects_list.append(project_id)
project = Projects.query.filter_by(id=project_id).first()
# Смотрим роли пользователей по проекту
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'])
or (current_user.username == 'Administrator')
or (current_user.id == project.author_id)):
allow_flag = True
if not allow_flag:
abort(403)
attachment = request.args.get('attachment')
filename = attachment
curr_folder_path = os.path.join('static', 'student_attachments')
directory = os.path.join(current_app.root_path, curr_folder_path,
'student_' + str(student_id))
curr_filepath = os.path.join(current_app.root_path, directory, filename)
os.remove(curr_filepath)
if len(os.listdir(directory)) == 0:
shutil.rmtree(directory, ignore_errors=True)
student.attach = None
db.session.commit()
else:
if student.attach:
attachments = json.loads(student.attach)
attachments.remove(filename)
student.attach = json.dumps(attachments)
db.session.commit()
flash('Прикрепленный к профилю участника файл удален', 'warning')
return redirect(url_for('student.update_student', student_id=student.id))
def delete_method(method_id):
method = Methodics.query.get_or_404(method_id)
##### РОЛЬ ДОСТУПА #####
# Смотрим роли пользователей по методике
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']) or
(current_user.username == 'Administrator') or
(current_user == method.author)):
abort(403)
# Удалем превьюшки картинок
del_meth_folder = os.path.join(
current_app.root_path,
os.path.join('static', 'methodics_pics', 'method_images',
'method_' + str(method_id)))
shutil.rmtree(del_meth_folder, ignore_errors=True)
# Удаляем заглавную картинку для методики
if method.method_label_image != 'default_method.png':
del_meth_ava = os.path.join(
current_app.root_path,
os.path.join('static', 'methodics_pics', 'method_ava',
method.method_label_image))
os.remove(del_meth_ava)
# Удаляем файлы презентации
if method.presentation:
for presentation in json.loads(method.presentation):
filename = presentation
curr_folder_path = os.path.join('static',
'methodics_presentations')
directory = os.path.join(current_app.root_path, curr_folder_path,
'method_' + str(method_id))
shutil.rmtree(directory, ignore_errors=True)
# Определяем номер тайминга и удаляем его и его шаги
timing_id = db.session.execute(
text(f"select timing_id from methodics where id='{method_id}'")).first(
)[0]
if timing_id != None:
db.session.execute(
text(
f"delete from timing_steps where method_timing_id='{timing_id}'"
))
db.session.execute(
text(f"delete from method_timing where id='{timing_id}'"))
# Удалние методики, после того как разобрались с констреинтами
db.session.delete(method)
db.session.commit()
flash('Методика удалена', 'success')
return redirect(url_for('core.index'))
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 delete_lesson(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)
##### РОЛЬ ДОСТУПА #####
# Смотрим роли пользователей по проекту
project_roles = get_roles(item_id=project.id, item_type=2)
# определяем роль пользователя
curr_user_role = user_role(project_roles, current_user.id)
# завершаем обработку если у пользователя не хватает прав
if not ((curr_user_role in ['admin'])
or (current_user.username == 'Administrator')
or (current_user.id == project.author_id)):
abort(403)
# Удаляем прикрепленные файлы
if lesson.attach:
for attachment in json.loads(lesson.attach):
filename = attachment
curr_folder_path = os.path.join('static', 'project_attachments',
'project_'+str(project.id),
'term_'+str(term.id),
'course_'+str(course.id))
directory = os.path.join(current_app.root_path, curr_folder_path, 'lesson_'+str(lesson_id))
shutil.rmtree(directory, ignore_errors=True)
# Удаляем пустые папки
curr_folder = os.path.join(current_app.root_path, 'static', 'project_attachments',
'project_'+str(project.id),
'term_'+str(term.id),
'course_'+str(course.id))
if len(os.listdir(curr_folder)) == 0:
shutil.rmtree(curr_folder, ignore_errors=True)
curr_folder = os.path.join(current_app.root_path, 'static', 'project_attachments',
'project_'+str(project.id),
'term_'+str(term.id))
if len(os.listdir(curr_folder)) == 0:
shutil.rmtree(curr_folder, ignore_errors=True)
curr_folder = os.path.join(current_app.root_path, 'static', 'project_attachments',
'project_'+str(project.id))
if len(os.listdir(curr_folder)) == 0:
shutil.rmtree(curr_folder, ignore_errors=True)
# Удалние проекта, после того как разобрались с констреинтами
db.session.delete(lesson)
db.session.commit()
flash('Занятие удалено', 'success')
return redirect(url_for('courses.course_view', course_id=course.id))
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 create_students_group(course_id):
"""
Создаем новую группу участников курса
"""
course = Courses.query.get_or_404(course_id)
term = term = Term.query.get_or_404(course.term_id)
project = Projects.query.get_or_404(term.project_id)
##### РОЛЬ ДОСТУПА #####
# Смотрим роли пользователей по проекту
project_roles = get_roles(item_id=project.id, item_type=2)
# определяем роль пользователя
curr_user_role = user_role(project_roles, current_user.id)
# завершаем обработку если у пользователя не хватает прав
if not ((curr_user_role in ['admin', 'moder']) or
(current_user.username == 'Administrator') or
(current_user.id == project.author_id)):
abort(403)
form = AddStudentsGroupForm()
if form.validate_on_submit():
students_group = StudentsGroup(author_id=current_user.id,
description=form.description.data)
db.session.add(students_group)
db.session.commit()
flash('Новая группа участников создана', 'success')
students_group = StudentsGroup.query.filter_by(
author_id=current_user.id,
description=form.description.data).order_by(
StudentsGroup.create_date.desc()).first()
course.students_group_id = students_group.id
db.session.commit()
return redirect(url_for('courses.course_view', course_id=course.id))
# Первая загрузка
return render_template('create_students_group.html',
form=form,
course_name=course.name,
course_id=course.id,
term=term,
project=project,
curr_user_role=curr_user_role,
course_label_image=course.label_image)
def create_lesson(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)
##### РОЛЬ ДОСТУПА #####
# Смотрим роли пользователей по проекту
project_roles = get_roles(item_id=project.id, item_type=2)
# определяем роль пользователя
curr_user_role = user_role(project_roles, current_user.id)
# завершаем обработку если у пользователя не хватает прав
if not ((curr_user_role in ['admin', 'moder'])
or (current_user.username == 'Administrator')
or (current_user.id == project.author_id)):
abort(403)
form = AddLessonForm()
if form.validate_on_submit():
lesson = Lessons(course_id=course.id,
description=form.description.data,
lesson_date = form.lesson_date.data,
start_time = form.start_time.data,
finish_time = form.finish_time.data)
db.session.add(lesson)
db.session.commit()
flash('Занятие создано', 'success')
if not form.start_time.data:
lesson = Lessons.query.filter_by(course_id=course_id, description=form.description.data, lesson_date = form.lesson_date.data).first()
else:
lesson = Lessons.query.filter_by(course_id=course_id, description=form.description.data, lesson_date = form.lesson_date.data, start_time = form.start_time.data).first()
return redirect(url_for('courses.update_lesson', lesson_id=lesson.id))
# Первая загрузка
return render_template('create_lesson.html',
form=form,
course = course,
project = project,
curr_user_role=curr_user_role,
term=term)
def delete_lesson_attachment(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)
##### РОЛЬ ДОСТУПА #####
# Смотрим роли пользователей по проекту
project_roles = get_roles(item_id=project.id, item_type=2)
# определяем роль пользователя
curr_user_role = user_role(project_roles, current_user.id)
# завершаем обработку если у пользователя не хватает прав
if not ((curr_user_role in ['admin', 'moder'])
or (current_user.username == 'Administrator')
or (current_user.id == project.author_id)):
abort(403)
attachment = request.args.get('attachment')
filename = attachment
curr_folder_path = os.path.join('static', 'project_attachments',
'project_'+str(project.id),
'term_'+str(term.id),
'course_'+str(course.id))
directory = os.path.join(current_app.root_path, curr_folder_path, 'lesson_'+str(lesson_id))
curr_filepath = os.path.join(current_app.root_path, directory, filename)
os.remove(curr_filepath)
if len(os.listdir(directory)) == 0:
shutil.rmtree(directory, ignore_errors=True)
lesson.attach = None
db.session.commit()
else:
if lesson.attach:
attachments = json.loads(lesson.attach)
attachments.remove(filename)
lesson.attach = json.dumps(attachments)
db.session.commit()
flash('Прикрепленный к занятию файл удален', 'warning')
# filepath = os.path.join(directory, filename)
return redirect(url_for('courses.update_lesson', lesson_id=lesson_id))
def add_method_to_lesson(method_id, 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)
##### РОЛЬ ДОСТУПА #####
# Смотрим роли пользователей по проекту
project_roles = get_roles(item_id=project.id, item_type=2)
# определяем роль пользователя
curr_user_role = user_role(project_roles, current_user.id)
# завершаем обработку если у пользователя не хватает прав
if not ((curr_user_role in ['admin', 'moder']) or
(current_user.username == 'Administrator') or
(current_user.id == project.author_id)):
abort(403)
lesson.method_id = method_id
db.session.commit()
return redirect(url_for('courses.update_lesson', lesson_id=lesson.id))
def create_course(term_id):
"""
Создаем новый курс для определенного периода выбранного проекта
"""
term = 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)
# определяем роль пользователя
curr_user_role = user_role(project_roles, current_user.id)
# завершаем обработку если у пользователя не хватает прав
if not ((curr_user_role in ['admin', 'moder'])
or (current_user.username == 'Administrator')
or (current_user.id == project.author_id)):
abort(403)
form = AddCourseForm()
if form.validate_on_submit():
course = Courses(project_id=project.id,
term_id = term.id,
name=form.name.data,
description=form.description.data,
start_date = form.start_date.data,
finish_date = form.finish_date.data)
db.session.add(course)
db.session.commit()
flash('Курс занятий создан', 'success')
course = Courses.query.filter_by(term_id=term_id, name=form.name.data).first()
return redirect(url_for('courses.update_course', course_id=course.id))
# Первая загрузка
return render_template('create_course.html',
form=form,
term_name = term.name,
project_name = project.name,
project=project,
curr_user_role=curr_user_role,
term=term)
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 update_schedule(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)
course_schedule = Lessons.query.filter_by(course_id=course.id).order_by(Lessons.lesson_date).order_by(Lessons.start_time).all()
##### РОЛЬ ДОСТУПА #####
# Смотрим роли пользователей по проекту
project_roles = get_roles(item_id=project.id, item_type=2)
# определяем роль пользователя
curr_user_role = user_role(project_roles, current_user.id)
# завершаем обработку если у пользователя не хватает прав
if not ((curr_user_role in ['admin', 'moder'])
or (current_user.username == 'Administrator')
or (current_user.id == project.author_id)):
abort(403)
# формируем словарь с привязанными к занятим методиками
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_schedule.html',
course_schedule=course_schedule,
course=course,
term=term,
project=project,
curr_user_role=curr_user_role,
methods_dict=methods_dict,
date_translate=date_translate,
len=len,
zip=zip)
def update_students_group_list(course_id):
"""
Изменяем состав группы участников курса
"""
session['course_id'] = course_id
course = Courses.query.get_or_404(course_id)
term = term = Term.query.get_or_404(course.term_id)
project = Projects.query.get_or_404(term.project_id)
##### РОЛЬ ДОСТУПА #####
# Смотрим роли пользователей по проекту
project_roles = get_roles(item_id=project.id, item_type=2)
# определяем роль пользователя
curr_user_role = user_role(project_roles, current_user.id)
# завершаем обработку если у пользователя не хватает прав
if not ((curr_user_role in ['admin', 'moder']) or
(current_user.username == 'Administrator') or
(current_user.id == project.author_id)):
abort(403)
students_group = StudentsGroup.query.get_or_404(course.students_group_id)
students_group_list = []
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())
return render_template('students_group_list.html',
group_name=students_group.description,
group_id=students_group.id,
students_group_list=students_group_list,
course_id=course.id,
course_name=course.name,
term=term,
project=project,
curr_user_role=curr_user_role,
course_label_image=course.label_image,
zip=zip,
len=len)
def delete_presentation(method_id):
"""
Удаляем презентацияю для выбранной методики вместе с директорией
"""
method = Methodics.query.get_or_404(method_id)
##### РОЛЬ ДОСТУПА #####
# Смотрим роли пользователей по методике
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)
presentation = request.args.get('presentation')
filename = presentation
curr_folder_path = os.path.join('static', 'methodics_presentations')
directory = os.path.join(current_app.root_path, curr_folder_path,
'method_' + str(method_id))
curr_filepath = os.path.join(current_app.root_path, directory, filename)
os.remove(curr_filepath)
if len(os.listdir(directory)) == 0:
shutil.rmtree(directory, ignore_errors=True)
method.presentation = None
db.session.commit()
else:
if method.presentation:
presentations = json.loads(method.presentation)
presentations.remove(filename)
method.presentation = json.dumps(presentations)
db.session.commit()
flash('Файл презентации удален', 'warning')
# filepath = os.path.join(directory, filename)
return redirect(url_for('methodics.update', method_id=method_id))
def step_update(step_id):
"""
Редактируем существующий этап (step_id) тайминга
"""
form = AddTimingStepsForm()
step = db.session.query(TimingSteps).filter_by(id=step_id).first()
timing_id = step.method_timing_id
method = Methodics.query.filter_by(timing_id=timing_id).first()
##### РОЛЬ ДОСТУПА #####
# Смотрим роли пользователей по методике
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)
if form.validate_on_submit():
step.step_seq_number = form.step_seq_number.data
step.step_duration = form.step_duration.data
step.step_desc = form.step_desc.data
step.step_result = form.step_result.data
db.session.commit()
return redirect(url_for('timing.edit_timing', method_id=method.id))
elif request.method == 'GET':
print(f'duration {step.step_duration}\ndescription {step.step_desc}')
form.step_seq_number.data = step.step_seq_number
form.step_duration.data = step.step_duration
form.step_desc.data = step.step_desc
form.step_result.data = step.step_result
form.check_duration_data_type(form.step_duration)
return render_template('add_timing_step.html', form=form)
def delete_from_list_student(student_id):
group_id = request.args.get('group_id')
course = Courses.query.filter_by(students_group_id=group_id).first()
term = term = Term.query.get_or_404(course.term_id)
project = Projects.query.get_or_404(term.project_id)
##### РОЛЬ ДОСТУПА #####
# Смотрим роли пользователей по проекту
project_roles = get_roles(item_id=project.id, item_type=2)
# определяем роль пользователя
curr_user_role = user_role(project_roles, current_user.id)
# завершаем обработку если у пользователя не хватает прав
if not ((curr_user_role in ['admin', 'moder']) or
(current_user.username == 'Administrator') or
(current_user.id == project.author_id)):
abort(403)
db.session.execute(
text(
f"delete from learning_groups where student_id='{student_id}' and group_id='{group_id}'"
))
db.session.commit()
return redirect(
url_for('students.update_students_group_list', course_id=course.id))
def create_term(project_id):
"""
Создаем новый период занятий для проекта
"""
project = Projects.query.get_or_404(project_id)
##### РОЛЬ ДОСТУПА #####
# Смотрим роли пользователей по проекту
project_roles = get_roles(item_id=project.id, item_type=2)
# определяем роль пользователя
curr_user_role = user_role(project_roles, current_user.id)
# завершаем обработку если у пользователя не хватает прав
if not ((curr_user_role in ['admin', 'moder'])
or (current_user.username == 'Administrator')
or (current_user.id == project.author_id)):
abort(403)
form = AddTermForm()
if form.validate_on_submit():
term = Term(project_id=project.id,
name=form.name.data,
description=form.description.data,
start_date=form.start_date.data,
finish_date=form.finish_date.data)
db.session.add(term)
db.session.commit()
flash('Период деятельности проекта создан', 'success')
term = Term.query.filter_by(project_id=project.id, name=form.name.data).first()
return redirect(url_for('projects.update_term', term_id=term.id))
# Первая загрузка
return render_template('create_term.html',
form=form,
project_name=project.name,
project_id=project.id)
def delete_timing_step(step_id):
"""
Удаляем этап (step_id) тайминга
"""
step = TimingSteps.query.get_or_404(step_id)
timing_id = step.method_timing_id
method = Methodics.query.filter_by(timing_id=timing_id).first()
##### РОЛЬ ДОСТУПА #####
# Смотрим роли пользователей по методике
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(f'id {step_id}, step_id {step_id}')
db.session.delete(step)
db.session.commit()
flash('Этап занятия удален', 'warning')
return redirect(url_for('timing.edit_timing', method_id=method.id))
def add_timing_step(timing_id):
"""
Создаем новый этап у тайминга timing_id
"""
method = Methodics.query.filter_by(timing_id=timing_id).first()
##### РОЛЬ ДОСТУПА #####
# Смотрим роли пользователей по методике
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)
form = AddTimingStepsForm()
if form.validate_on_submit():
timing_step = TimingSteps(method_timing_id=timing_id,
step_seq_number=form.step_seq_number.data,
step_duration=form.step_duration.data,
step_desc=form.step_desc.data,
step_result=form.step_result.data)
db.session.add(timing_step)
db.session.commit()
return redirect(url_for('timing.edit_timing', method_id=method.id))
# Если первая загрузка формы поле step_duration не проверяем.
if (form.step_duration.data == None and
(form.step_desc.data != None or form.step_result.data != None)):
form.check_duration_data_type(form.step_duration)
return render_template('add_timing_step.html',
form=form,
timing_id=timing_id)
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 update(method_id):
method = Methodics.query.get_or_404(method_id)
session['method_id'] = method.id
session.pop('project_id', None)
##### РОЛЬ ДОСТУПА #####
# Смотрим роли пользователей по методике
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)
# Берем из базы пользователей с какими нибудь правами по методике
users_role_dict = {}
roles = UserRole.query.filter(UserRole.item_type == 1,
UserRole.item_id == method.id).all()
if roles:
for role in roles:
user = User.query.filter_by(id=role.user_id).first()
users_role = role.role_type
users_role_dict[user.id] = (user.username, users_role, role.id)
# текущая категория и список всех категорий
category = Categories.query.get(method.category)
html_category_list = get_html_category_list()
# Формируем список с файлами презентаций
presentations = []
if method.presentation:
for presentation in json.loads(method.presentation):
presentations.append(presentation)
# проверка на наличие тайминга занятия
timing_exist = MethodTiming.query.filter_by(method_id=method_id).first()
if timing_exist:
timing_id = timing_exist.id
else:
timing_id = None
form = UpdateMethodForm()
# print(f'form errors:{form.errors}')
# если основные проверки пройденны и форма счетается заполненной
if form.validate_on_submit():
# Делаем дополнительные проверки из класса формы
try:
# Проверка того что минимальный возраст меньше максимального
form.check_age_range(form.age_range_from.data,
form.age_range_till.data)
except ValidationError:
flash(
'Ошибка. Минимальный возраст участников не может быть больше максимального.',
'negative')
return render_template(
'update_method.html',
method_label_image=method.method_label_image,
title='Редактирование методики',
method_id=method.id,
users_role_dict=users_role_dict,
curr_user_role=curr_user_role,
timing_id=form.timing_id.data,
form=form,
# curr_presentation = presentation_filename,
category=category,
html_category_list=html_category_list,
presentations=presentations)
# Если пытаются изменить заглавную картинку
if form.method_label_image.data:
method_id = method.id
pic = add_method_pic(form.method_label_image.data, method_id,
method.method_label_image)
method.method_label_image = pic
# Если пытаются загрузить файл с ПРЕЗЕНТАЦИЕЙ формируем общий список, переводим в форма JSON и сохраняем в базу
if form.presentation.data:
method_id = method.id
if method.presentation:
presentation_files_list = json.loads(method.presentation)
else:
presentation_files_list = []
presentation_filename = add_method_presentation(
form.presentation.data, method_id, method.presentation)
presentation_files_list.append(presentation_filename)
json_presentations = json.dumps(presentation_files_list)
method.presentation = json_presentations
# создание превьюшек КАРТИНОК по указанным ссылкам
print(f'image processing for method {method.id}')
images_data = form.images.data
wrong_links = []
# Проверяем данные в форме и базе на совпадение, чтобы лишний раз не обрабатывать если ничего не изменилось
if not check_url_list(form.images.data, method.images):
image_html_links = text_format_for_html(form.images.data)
thumb_links, wrong_links, images_data = thumbnail_for_net_pic(
image_html_links, method.id)
# обработка ссылок на Yandex.MUSIC
print(f'music processing for method {method.id}')
# print(f'form.music.data: {form.music.data}')
music_data = form.music.data
wrong_music_links = []
if not check_url_list(form.music.data, method.music):
music_html_links = text_format_for_html(form.music.data)
wrong_music_links, music_data = check_music_link(
music_html_links, method_id)
# обработка ссылок на ВИДЕО
print(f'video processing for method {method.id}')
video_data = form.video.data
wrong_video_links = []
if not check_url_list(form.video.data, method.video):
video_html_links = text_format_for_html(form.video.data)
wrong_video_links, video_data = check_video_links(
video_html_links, method_id)
# смотрим вбранную категорию
curr_category = int(request.form.get('form_category'))
method.change_date = datetime.utcnow()
method.title = form.title.data
method.short_desc = form.short_desc.data
method.target = form.target.data
method.description = form.description.data
method.age_from = form.age_range_from.data
method.age_till = form.age_range_till.data
method.consumables = form.consumables.data
method.timing_id = timing_id
# method.presentation = form.presentation.data
method.images = images_data
method.music = music_data
method.video = video_data
method.literature = form.literature.data
method.category = curr_category
method.tags = form.tags.data
db.session.commit()
flash_text = 'Изменения и дополнения сохранены.'
# или при необходимости показываем ругань на битые ссылки
if len(wrong_links) == 0 and len(wrong_video_links) == 0 and len(
wrong_music_links) == 0:
flash(flash_text, 'success')
else:
if len(wrong_links) != 0:
flash_text += '<br>но ссылка на <strong>картинку</strong> (или несколько) не открывается. Проверьте правильность ссылки:<br> '
for link in wrong_links:
flash_text += link + '<br>'
if len(wrong_video_links) != 0:
flash_text += '<br>Не обработалась ссылка/ки на <strong>видео</strong>: <br>'
for link in wrong_video_links:
flash_text += link + '<br>'
if len(wrong_music_links) != 0:
flash_text += '<br>Cсылка/ки на <strong>музыку</strong> не похожа на HTML-код для Яндекс.музыки, проверьте: <br>'
for link in wrong_music_links:
flash_text += link + '<br>'
flash(Markup(flash_text), 'negative')
return redirect(url_for('methodics.method', method_id=method_id))
# Первоначальное открытие формы на редактирование
elif request.method == 'GET':
# Если задан тайминг, показываем длительность занятия
timing = MethodTiming.query.filter_by(method_id=method_id).first()
if timing:
form.timing_id.data = timing.duration
else:
form.timing_id.data = method.timing_id
# Название категории
category = Categories.query.get(method.category)
form.title.data = method.title
form.short_desc.data = method.short_desc
form.target.data = method.target
form.age_range_from.data = method.age_from
form.age_range_till.data = method.age_till
form.description.data = method.description
form.consumables.data = method.consumables
form.images.data = method.images
form.music.data = method.music
form.video.data = method.video
form.literature.data = method.literature
form.category.data = category
form.tags.data = method.tags
method_label_image = url_for('static',
filename='methodics_pics/method_ava' +
method.method_label_image)
# Если форма заполненна с ошибками, а валидаторам плевать (например расширения файлов)
print(f'form errors: {form.errors}')
if form.errors:
flash_text = 'Форма методики заполнена неверно. <br>'
for error in form.errors:
# print(form.errors[error])
flash_text += form.errors[error][0] + '<br>'
flash_text += 'К сожалению, последние изменения не сохранены. '
flash(Markup(flash_text), 'negative')
return render_template(
'update_method.html',
method_label_image=method.method_label_image,
title='Редактирование методики',
method_id=method.id,
method=method,
users_role_dict=users_role_dict,
curr_user_role=curr_user_role,
timing_id=form.timing_id.data,
form=form,
# curr_presentation = presentation_filename,
category=category,
html_category_list=html_category_list,
presentations=presentations)
def update_project(project_id):
"""
Редактируем и дополняем существующюю запись для проекта project_id
"""
project = Projects.query.get_or_404(project_id)
form = UpdateProjectForm()
session['project_id'] = project.id
session.pop('method_id', None)
##### РОЛЬ ДОСТУПА #####
# Смотрим роли пользователей по проекту
project_roles = get_roles(item_id=project.id, item_type=2)
# определяем роль пользователя
curr_user_role = user_role(project_roles, current_user.id)
# завершаем обработку если у пользователя не хватает прав
if not ((curr_user_role in ['admin', 'moder'])
or (current_user.username == 'Administrator')
or (current_user.id == project.author_id)):
abort(403)
# Берем из базы пользователей с какими нибудь правами по проекту
users_role_dict = {}
roles = UserRole.query.filter(UserRole.item_type==2, UserRole.item_id==project.id).all()
if roles:
for role in roles:
user = User.query.filter_by(id=role.user_id).first()
users_role = role.role_type
users_role_dict[user.id] = (user.username, users_role, role.id)
# print(f'users_role_dict: {users_role_dict}')
if form.validate_on_submit():
# Если загружается картинка для Проекта
if form.label_image.data:
project_id = project.id
pic = add_project_pic(form.label_image.data, project_id, project.label_image)
project.label_image = pic
# Если загружается дополнительный файл
# формируем общий список, переводим в форма JSON и сохраняем в базу
if form.attach.data:
project_id = project.id
if project.attach:
attachments_files_list = json.loads(project.attach)
else:
attachments_files_list = []
attachment_filename = add_attachment(form.attach.data, project_id, project.attach)
attachments_files_list.append(attachment_filename)
json_attachments = json.dumps(attachments_files_list)
project.attach = json_attachments
project.name = form.name.data
project.change_date = datetime.utcnow()
project.short_desc = form.short_desc.data
project.description = form.description.data
project.contacts_info = form.contacts_info.data
project.moders_list = form.moders_list.data
project.address = form.address.data
project.note = form.note.data
project.web_links = form.web_links.data
db.session.commit()
return redirect(url_for('projects.project_view', project_id=project.id))
# Первоначальное открытие формы на редактирование
elif request.method == 'GET':
form.name.data = project.name
form.short_desc.data = project.short_desc
form.description.data = project.description
form.moders_list.data = project.moders_list
form.contacts_info.data = project.contacts_info
form.moders_list.data = project.moders_list
form.address.data = project.address
form.note.data = project.note
form.web_links.data = project.web_links
label_image = url_for('static', filename = 'projects_pics/project_ava/'+project.label_image)
# Формируем список с прикрепленными файлами
attachments = []
if project.attach:
for attachment in json.loads(project.attach):
attachments.append(attachment)
# Если форма заполненна с ошибками, а валидаторам плевать (например расширения файлов)
# print(f'form errors: {form.errors}')
if form.errors:
flash_text = 'Форма методики заполнена неверно. <br>'
for error in form.errors:
# print(form.errors[error])
flash_text += form.errors[error][0]
flash_text += 'К сожалению, последние изменения не сохранены. '
flash(Markup(flash_text), 'negative')
return render_template('update_project.html',
label_image=label_image,
project_id = project.id,
project=project,
curr_user_role = curr_user_role,
form=form,
attachments=attachments,
users_role_dict = users_role_dict)
