class Document(object):
def __init__(self, templ_docx):
self._doc = DocxTemplate(templ_docx)
self._pic_to_render = {}
self._context = {}
self._chapter = {}
self._sequence = 0
def sequence(self):
self._sequence = self._sequence + 1
return self._sequence
def add_context(self, context={}):
self._context = context.copy()
def add_heading(self, title, level=1):
docx = self._doc.get_docx()
docx.add_heading(title, level)
def add_chapter(self, chapter, title=None, level=2, remove_file=True):
try:
docx = self._doc.get_docx()
if title is not None:
docx.add_heading(title, level)
id = "chapter" + str(self.sequence())
chapter.render()
docx.add_paragraph("{{p " + id + "}}")
self._chapter[id] = self._doc.new_subdoc(chapter.get_filename())
pic_to_add = chapter.get_pic_to_add()
if pic_to_add:
for pic in pic_to_add:
path = pic_to_add[pic]["path"]
width = pic_to_add[pic]["width"]
self._pic_to_render[pic] = InlineImage(self._doc,
path,
width=Mm(width))
finally:
if remove_file:
chapter.remove_file()
def inlineimage(self, image_file, image_width=147):
return InlineImage(self._doc, image_file, width=Mm(image_width))
def render(self):
if self._chapter or self._context:
self._context.update(self._chapter)
self._doc.render(self._context)
if self._pic_to_render:
self._doc.render(self._pic_to_render)
def save(self, filename):
self._doc.save(filename)
def print_form(name):
filename = os.path.join(FORMS_FOLDER, name)
doc = DocxTemplate(filename)
doc.render(request.args.to_dict())
stream = BytesIO()
doc.get_docx().save(stream)
stream.seek(0)
return send_file(stream, mimetype='docx')
def fill_table_4(template: DocxTemplate, context: Dict[str, Any]) -> None:
""" Заполняем таблицу с содержанием СРС в разделе 4 """
themes = context['course'].themes
themes_count = len(themes)
subject = context['subject']
homeworks = distribute(subject.get_hours('homeworks'), themes_count)
table = template.get_docx().tables[5]
core.add_table_rows(table,
themes_count + 1) # последняя строка - для итога
hw_text = "Проработка теоретического материала, подготовка к выполнению лабораторной работы"
hw_control = "Вопросы к итоговому тесту"
i = 0
for theme in themes:
i += 1
core.set_cell_text(table, i, 0, core.CENTER, str(i))
core.set_cell_text(table, i, 1, core.CENTER, theme['тема'])
core.set_cell_text(table, i, 2, core.CENTER, hw_text)
core.set_cell_text(table, i, 3, core.CENTER,
str_or_dash(homeworks[i - 1]))
core.set_cell_text(table, i, 4, core.CENTER, hw_control)
i += 1
core.set_cell_text(table, i, 1, core.JUSTIFY, 'Всего часов')
core.set_cell_text(table, i, 3, core.CENTER, str_or_dash(sum(homeworks)))
core.fix_table_borders(table)
def fill_table_3_1(template: DocxTemplate, context: Dict[str, Any]) -> None:
""" Заполняем таблицу с содержанием курса в разделе 3.1 """
# Извлекаем названия тем и форматируем для заполнения таблицы
course, subject = context['course'], context['subject']
themes = [
'Тема %d. %s' % (i + 1, t['тема']) for i, t in enumerate(course.themes)
]
# Равномерно размазываем часы по темам
themes_count = len(themes)
lectures = distribute(subject.get_hours('lectures'), themes_count)
practices = distribute(subject.get_hours('practices'), themes_count)
labworks = distribute(subject.get_hours('labworks'), themes_count)
controls = distribute(subject.get_hours('controls'), themes_count)
homeworks = distribute(subject.get_hours('homeworks'), themes_count)
totals = [
sum(t) for t in zip(lectures, practices, labworks, controls, homeworks)
]
# Заполняем таблицу
table = template.get_docx().tables[4]
core.add_table_rows(table,
themes_count + 1) # последняя строка - для итога
fill_table_column(table, 2, [0], themes + ['Всего часов'])
fill_table_column(table, 2, [1], totals + [subject.get_total_hours()])
fill_table_column(table, 2, [2], lectures + [sum(lectures)])
fill_table_column(table, 2, [4], practices + [sum(practices)])
fill_table_column(table, 2, [6], labworks + [sum(labworks)])
fill_table_column(table, 2, [10], controls + [sum(controls)])
fill_table_column(table, 2, [11], homeworks + [sum(homeworks)])
fill_table_column(table, 2, [3, 5, 7, 8, 9],
[0] * (themes_count + 1)) # пустые значения
core.fix_table_borders(table)
def fill_section_2_2(template: DocxTemplate, context: Dict[str, any]) -> None:
""" Заполнение раздела 2.2 """
marker = None
for paragraph in template.get_docx().paragraphs:
keywords = ['оценочные средства для', 'государственной итоговой аттестации']
if all(kw in paragraph.text.lower() for kw in keywords):
marker = paragraph
break
plan: EducationPlan = context['plan']
subjects = sorted(plan.subject_codes.values(), key=Subject.repr)
for subj in subjects:
rpd = get_rpd(subj.name)
if not rpd:
continue
paragraph = marker.insert_paragraph_before('%s %s' % (subj.code, subj.name))
paragraph.paragraph_format.alignment = WD_PARAGRAPH_ALIGNMENT.CENTER
paragraph.paragraph_format.first_line_indent = Cm(0)
for run in paragraph.runs:
run.bold = True
for item in iterate_items(Document(rpd)):
if isinstance(item, Paragraph):
paragraph = marker.insert_paragraph_before(item.text)
paragraph.paragraph_format.alignment = WD_PARAGRAPH_ALIGNMENT.JUSTIFY
paragraph.paragraph_format.first_line_indent = Cm(0)
def fill_table_4(template: DocxTemplate, context: Dict[str, any]) -> None:
""" Заполнение бланка "Лист сформированности компетенций" """
plan: EducationPlan = context['plan']
table: Table = template.get_docx().tables[-1]
row_number = 0
for competence in sorted(plan.competence_codes.values(), key=Competence.repr):
core.add_table_rows(table, 1)
row_index = len(table.rows) - 1
row_number += 1
core.set_cell_text(table, row_index, 0, core.CENTER, str(row_number))
core.set_cell_text(table, row_index, 1, core.JUSTIFY, competence.code + ' ' + competence.description)
subjects = [plan.subject_codes[s] for s in competence.subjects]
for subject in sorted(subjects, key=Subject.repr):
core.add_table_rows(table, 1)
row_index = len(table.rows) - 1
core.set_cell_text(table, row_index, 1, core.JUSTIFY, subject.code + ' ' + subject.name)
core.add_table_rows(table, 1)
row_number += 1
row_index = len(table.rows) - 1
core.set_cell_text(table, row_index, 0, core.CENTER, str(row_number))
core.set_cell_text(table, row_index, 1, core.JUSTIFY, 'Практики')
core.add_table_rows(table, 1)
row_number += 1
row_index = len(table.rows) - 1
core.set_cell_text(table, row_index, 0, core.CENTER, str(row_number))
core.set_cell_text(table, row_index, 1, core.JUSTIFY, 'НИР')
core.fix_table_borders(table)
def fill_table_7(template: DocxTemplate, context: Dict[str, Any]) -> None:
""" Заполняем таблицу со ссылками на литературу в разделе 7 """
if context['lit_images']:
return # вместо таблицы будет скан страницы с печатью
def append_table_7_section(caption, books):
rows_count = len(table.rows)
core.add_table_rows(table, len(books) + 1) # доп. строка для заголовка
table.cell(rows_count, 0).merge(table.cell(rows_count, 4))
core.set_cell_text(table, rows_count, 0, core.CENTER, caption)
for i, book in enumerate(books):
core.set_cell_text(table, rows_count + i + 1, 0, core.CENTER,
str(i + 1))
core.set_cell_text(table, rows_count + i + 1, 1, core.CENTER,
book['гост'])
core.set_cell_text(table, rows_count + i + 1, 2, core.CENTER,
book['гриф'])
core.set_cell_text(table, rows_count + i + 1, 3, core.CENTER,
book['экз'])
core.set_cell_text(table, rows_count + i + 1, 4, core.CENTER,
book['эбс'])
table = template.get_docx().tables[9]
append_table_7_section('Основная литература',
context['course'].primary_books)
append_table_7_section('Дополнительная литература',
context['course'].secondary_books)
core.fix_table_borders(table)
def fill_table_2_1(template: DocxTemplate, context: Dict[str, any]) -> None:
""" Заполнение таблицы в разделе 2.1 """
plan: EducationPlan = context['plan']
table: Table = template.get_docx().tables[3]
for subject in sorted(plan.subject_codes.values(), key=Subject.repr):
core.add_table_rows(table, 1)
row_index = len(table.rows) - 1
core.set_cell_text(table, row_index, 0, core.CENTER, subject.code)
core.set_cell_text(table, row_index, 1, core.JUSTIFY, subject.name)
core.fix_table_borders(table)
class Chapter(object):
def __init__(self, templ_docx):
self._templ = DocxTemplate(templ_docx)
self._uuid = str(uuid.uuid1()).replace("-", "")
self._context = {}
self._pic_to_add = {}
def uuid(self):
return self._uuid
def add_context(self, context={}):
self._context = context.copy()
def add_picture(self, name, path, width=147):
pic_name = "%s_%s" % (name, self._uuid)
self._context[name] = "{{" + pic_name + "}}"
self._pic_to_add[pic_name] = {"path": path, "width": width}
def render(self, to_save_file=None):
self._templ.render(self._context)
if to_save_file is None:
self.save(self.uuid() + ".docx")
else:
self.save(to_save_file)
def save(self, filename=None):
self._templ.save(filename)
self._filename = filename
def get_filename(self):
return self._filename
def get_docx(self):
self._templ.get_docx()
def remove_file(self):
os.remove(self._filename)
def get_pic_to_add(self):
return self._pic_to_add
def get(self, request, *args, **kwargs):
obj = self.get_object()
self.object = obj
acc = get_object_or_404(Abon, username=self.kwargs.get('uname'))
try:
doc = DocxTemplate(obj.doc_template.path)
context = self.get_context_data(object=obj)
context.update(self.get_context_account(acc))
doc.render(context)
destination_document_file = BytesIO()
doc.get_docx().save(destination_document_file)
resp = HttpResponse(destination_document_file.getvalue(),
content_type=CONTENT_TYPE.WML_DOCUMENT)
resp[
'Content-Disposition'] = 'attachment; filename="document.docx"'
return resp
except (UndefinedError, ValidationError, TemplateSyntaxError) as e:
messages.error(request, str(e))
return redirect('docsapp:docs_list')
def create_file_docx_from_template(template_path, data):
file_name = get_filename(template_path, prefix='doc')
document = DocxTemplate(template_path)
document.render(data)
file = document.get_docx()
stream = BytesIO()
file.save(stream)
stream.seek(0)
try:
storage.upload_file_obj(stream, file_name, DOCX_MINE_TYPE)
stream.close()
except Exception as e:
raise ApplicationError(str(e))
return file_name
def create_order(context: Union[dict, Box]) -> None:
doc = DocxTemplate(join(TEMPLATES_FOLDER, "Order.docx"))
target_folder = join(TASKS_FOLDER, context.order_number)
try:
mkdir(target_folder)
except FileExistsError:
warn(f"Directory {target_folder} exist")
doc.render(context)
remove_row(doc.get_docx().tables[0], 1)
filename = f"ЗН №{context.order_number}"
file_path = join(target_folder, f"{filename}.docx")
doc.save(file_path)
def create_act(order_number):
target_folder = join(TASKS_FOLDER, order_number)
try:
context = get_context_from_order(
join(TASKS_FOLDER, order_number, f"ЗН №{order_number}.docx"))
context.order_number = order_number
except FileNotFoundError:
print("Заказа с данным номером нет")
return
doc = DocxTemplate(join(TEMPLATES_FOLDER, "Act.docx"))
doc.render(context)
remove_row(doc.get_docx().tables[0], 1)
filename = join(target_folder, f"Акт №{order_number}.docx")
doc.save(filename)
doc2pdf(filename, join(target_folder, f"Акт №{order_number}.pdf"))
def fill_table_1(template: DocxTemplate, context: Dict[str, any]) -> None:
""" Заполнение таблиц с формами контроля """
control_fancy_name = {
CT_EXAM: 'Экзамен',
CT_CREDIT_GRADE: 'Зачет с оценкой',
CT_CREDIT: 'Зачет',
CT_COURSEWORK: 'Курсовой проект',
}
plan: EducationPlan = context['plan']
if plan.degree == core.BACHELOR:
core.remove_table(template, 1)
elif plan.degree == core.MASTER:
core.remove_table(template, 2)
table: Table = template.get_docx().tables[1]
row_number = 0
for competence in sorted(plan.competence_codes.values(),
key=Competence.repr):
core.add_table_rows(table, 1)
row = len(table.rows) - 1
row_number += 1
core.set_cell_text(table, row, 0, core.CENTER, str(row_number))
core.set_cell_text(table, row, 1, core.JUSTIFY,
competence.code + ' ' + competence.description)
table.cell(row, 1).merge(table.cell(row, len(table.columns) - 1))
subjects = [plan.subject_codes[s] for s in competence.subjects]
for subject in sorted(subjects, key=Subject.repr):
core.add_table_rows(table, 1)
row = len(table.rows) - 1
row_number += 1
core.set_cell_text(table, row, 0, core.CENTER, str(row_number))
core.set_cell_text(table, row, 1, core.JUSTIFY,
subject.code + ' ' + subject.name)
for number, semester in subject.semesters.items():
controls = [control_fancy_name[c] for c in semester.control]
core.set_cell_text(table, row, number + 1, core.CENTER,
', '.join(controls))
core.fix_table_borders(table)
def fill_table_1_2(template: DocxTemplate, context: Dict[str, Any]) -> None:
""" Заполняем таблицу с компетенциями в разделе 1.2 """
table = template.get_docx().tables[1]
core.add_table_rows(table, len(context['subject'].competencies))
row = 0
competencies = [
context['plan'].competence_codes[c]
for c in context['subject'].competencies
]
for competence in sorted(competencies, key=Competence.repr):
row += 1
core.set_cell_text(table, row, 0, core.CENTER, competence.category)
core.set_cell_text(table, row, 1, core.JUSTIFY,
competence.code + ' ' + competence.description)
core.set_cell_text(table, row, 4, core.CENTER,
context['course'].assessment)
for ind_code in sorted(competence.indicator_codes):
indicator = competence.indicator_codes[ind_code]
core.set_cell_text(table, row, 2, core.JUSTIFY,
ind_code + ' ' + indicator.description)
def add_study_results(attr: str, caption: str) -> None:
""" Добавить в ячейку таблицы результаты обучения """
results = context['course'].__getattribute__(attr)
if results:
core.set_cell_text(table, 1, 3, core.JUSTIFY, caption)
for elem in results:
core.set_cell_text(table, 1, 3, 'Table List', '•\t' + elem)
table.cell(1, 3).merge(table.cell(row, 3))
add_study_results('knowledge', 'Знать:')
add_study_results('abilities', 'Уметь:')
add_study_results('skills', 'Владеть:')
core.fix_table_borders(table)
def fill_table_2(template: DocxTemplate, context: Dict[str, any]) -> None:
""" Заполнение таблиц с формами контроля """
global fileslist
control_fancy_name = {
CT_EXAM: 'Экзамен',
CT_CREDIT_GRADE: 'Зачет с оценкой',
CT_CREDIT: 'Зачет',
CT_COURSEWORK: 'Курсовой проект',
}
plan: EducationPlan = context['plan']
table: Table = template.get_docx().tables[2]
fileslist = [
filename[:-5] for filename in os.listdir('./rpds')
if filename.endswith('.docx')
]
row_number = 0
for competence in sorted(plan.competence_codes.values(),
key=Competence.repr):
core.add_table_rows(table, 1)
row = len(table.rows) - 1
row_number += 1
core.set_cell_text(table, row, 0, core.CENTER, str(row_number))
core.set_cell_text(table, row, 1, core.JUSTIFY,
competence.code + ' ' + competence.description)
for runover in range(2, 8):
core.set_cell_text(table, row, runover, core.JUSTIFY, ' ')
# table.cell(row, 1).merge(table.cell(row, len(table.columns) - 1))
subjects = [plan.subject_codes[s] for s in competence.subjects]
for subject in sorted(subjects, key=Subject.repr):
# core.add_table_rows(table, 1)
# row = len(table.rows) - 1
# len(table.rows) - 1
# row_number += 1
controls = []
for number, semester in subject.semesters.items():
controls += [control_fancy_name[c] for c in semester.control]
sem = 0
for control in controls:
core.add_table_rows(table, 1)
row = len(table.rows) - 1
zuv_criteria = find_rpd(subject.code, subject.name, control,
controls, sem)
sem += 1
if len(zuv_criteria) == 6:
core.set_cell_text(table, row, 0, core.CENTER, ' ')
core.set_cell_text(table, row, 1, core.JUSTIFY,
subject.code + ' ' + subject.name)
core.set_cell_text(table, row, 2, core.JUSTIFY,
zuv_criteria[0])
if control == 'Зачет':
core.set_cell_text(table, row, 3, core.JUSTIFY,
zuv_criteria[1])
core.set_cell_text(table, row, 4, core.JUSTIFY, ' ')
core.set_cell_text(table, row, 5, core.JUSTIFY, ' ')
core.set_cell_text(table, row, 6, core.JUSTIFY,
zuv_criteria[4])
table.cell(row, 3).merge(table.cell(row, 5))
else:
core.set_cell_text(table, row, 3, core.JUSTIFY,
zuv_criteria[1])
core.set_cell_text(table, row, 4, core.JUSTIFY,
zuv_criteria[2])
core.set_cell_text(table, row, 5, core.JUSTIFY,
zuv_criteria[3])
core.set_cell_text(table, row, 6, core.JUSTIFY,
zuv_criteria[4])
core.set_cell_text(table, row, 7, core.JUSTIFY,
zuv_criteria[5])
core.fix_table_borders(table)
def main():
config = configparser.ConfigParser()
config.read('autotemplation.ini')
template_folder_ids = config['DEFAULT']['TemplateFolderID'].split(',')
destination_folder_name = config['DEFAULT']['DestinationFolderName']
credentials = get_credentials()
http = credentials.authorize(httplib2.Http())
drive_service = discovery.build('drive', 'v3', http=http)
destination_folder_id = get_or_create_destination_folder_id(
drive_service, destination_folder_name)
template_file = get_template(drive_service, template_folder_ids)
mime_type, is_sheet = get_mime_type(template_file['mimeType'])
request = drive_service.files().export_media(
fileId=template_file['id'],
mimeType=mime_type)
fh = io.BytesIO()
downloader = MediaIoBaseDownload(fh, request)
done = False
while done is False:
status, done = downloader.next_chunk()
print("Download %d%%." % int(status.progress() * 100))
if is_sheet:
print("Spreadsheet selected, converting to Doc. (Slow)")
table_data = get_sheet_data(fh)
row_count = len(table_data)
col_count = len(table_data[0])
document = Document()
doc_table = document.add_table(rows=row_count,
cols=col_count)
for r, row in enumerate(table_data):
row_cells = doc_table.rows[r].cells
print("Converting row {}/{}...".format(r+1, row_count), end="\r")
for i, cell in enumerate(row):
if cell:
row_cells[i].text = cell
print("Conversion complete. "
"Warning: Processing large sheets will take some time.")
temp_doc_file = io.BytesIO()
document.save(temp_doc_file)
doc = DocxTemplate(temp_doc_file)
else:
doc = DocxTemplate(fh)
full_doc = doc.get_docx()
template_vars = get_template_variables(full_doc, template_file['name'])
if any('__' in x for x in template_vars):
worksheet = get_worksheet(credentials)
worksheet_headers = get_worksheet_headers(worksheet)
context = dict()
get_date_and_set_context(context)
for var in template_vars:
if var not in context:
if '__' in var:
context[var] = worksheet_lookup(
worksheet, worksheet_headers, var)
else:
context[var] = input("Enter a value for {}: ".format(var))
new_file_name = get_target_name(template_file['name'], context)
doc.render(context)
temp_file = tempfile.NamedTemporaryFile()
doc.save(temp_file)
if is_sheet:
csv_name = '{}.csv'.format(new_file_name)
doc_csv = DocxTemplate(temp_file)
csv_data = get_table_data_for_csv(doc_csv)
if csv_data:
with open(csv_name, 'w') as output:
writer = csv.writer(output, lineterminator='\n')
writer.writerows(csv_data)
print('{} created in local folder'.format(csv_name))
else:
print('Unable to create CSV. '
'Less than or more than 1 table found.')
workbook = Workbook()
sheet = workbook.get_active_sheet()
for row in csv_data:
sheet.append(row)
workbook.save(temp_file)
upload_mimetype = 'application/vnd.google-apps.spreadsheet'
else:
upload_mimetype = 'application/vnd.google-apps.document'
file_metadata = {
'name': new_file_name,
'parents': [destination_folder_id],
'mimeType': upload_mimetype
}
media = MediaFileUpload(temp_file.name,
mimetype=mime_type,
resumable=True)
drive_service.files().create(body=file_metadata,
media_body=media,
fields='id').execute()
print('{} placed in folder {}.'.format(new_file_name,
destination_folder_name))
temp_file.close()
def remove_table(template: DocxTemplate, table_index: int) -> None:
""" Удаляем таблицу из шаблона по её индексу """
docx = template.get_docx()
table_element = docx.tables[table_index]._element # pylint: disable=protected-access
parent_element = table_element.getparent()
parent_element.remove(table_element)
def fill_table_1(template: DocxTemplate, context: Dict[str, any]) -> None:
""" Заполнение таблиц с формами контроля """
# control_fancy_name = {
# core.CT_EXAM: 'Экзамен',
# core.CT_CREDIT_GRADE: 'Зачет с оценкой',
# core.CT_CREDIT: 'Зачет',
# core.CT_COURSEWORK: 'Курсовой проект',
# }
plan: EducationPlan = context['plan']
if plan.degree == core.BACHELOR:
core.remove_table(template, 1)
elif plan.degree == core.MASTER:
core.remove_table(template, 2)
table: Table = template.get_docx().tables[1]
row_number = 0
for competence in sorted(plan.competence_codes.values(), key=Competence.repr):
core.add_table_rows(table, 1)
row = len(table.rows) - 1
row_number += 1
core.set_cell_text(table, row, 0, core.CENTER, str(row_number))
core.set_cell_text(table, row, 1, core.JUSTIFY, competence.code + ' ' + competence.description)
for number in range(1, 9 if plan.degree == core.BACHELOR else 5):
cell_components = []
subjects = [plan.subject_codes[s] for s in competence.subjects]
subjects.sort(key=lambda s: s.code)
for subject in subjects:
for sem_num, sem_work in subject.semesters.items():
if sem_num == number:
if sem_work.control:
values = subject.code, subject.name, ', '.join(sem_work.control)
cell_components.append('%s %s (%s)' % values)
else:
values = subject.code, subject.name
cell_components.append('%s %s' % values)
core.set_cell_text(table, row, number + 1, core.CENTER, '\n'.join(cell_components))
core.fix_table_borders(table)
rpd_dict = context['rpd_dict']
table: Table = template.get_docx().tables[2]
row_number1 = 0
for competence in sorted(plan.competence_codes.values(), key=Competence.repr):
core.add_table_rows(table, 1)
row = len(table.rows) - 1
row_number1 += 1
core.set_cell_text(table, row, 0, core.CENTER, str(row_number1))
core.set_cell_text(table, row, 1, core.JUSTIFY, competence.code + ' ' + competence.description)
values = ['%s %s' % (k, v.description) for k, v in competence.indicator_codes.items()]
core.set_cell_text(table, row, 2, core.JUSTIFY, '\n'.join(values))
row_number2 = 0
subjects = [plan.subject_codes[s] for s in competence.subjects]
for subject in subjects:
if not subject.code.startswith('Б1'):
continue
zuv_raw = ''
rpd = rpd_dict.get(subject.code)
if rpd:
zuv = rpd.competences.get(competence.code)
if zuv:
zuv_raw = zuv.raw
core.add_table_rows(table, 1)
row = len(table.rows) - 1
row_number2 += 1
core.set_cell_text(table, row, 0, core.CENTER, '%d.%d' % (row_number1, row_number2))
core.set_cell_text(table, row, 1, core.JUSTIFY, subject.code + ' ' + subject.name)
core.set_cell_text(table, row, 3, core.JUSTIFY, zuv_raw)
core.set_cell_text(table, row, 4, core.JUSTIFY, zuv_raw)
core.set_cell_text(table, row, 5, core.JUSTIFY, zuv_raw)
core.set_cell_text(table, row, 6, core.JUSTIFY, zuv_raw)
core.fix_table_borders(table)
def fill_section_2_2(template: DocxTemplate, context: Dict[str, any]) -> None:
global table_flazhok
control_fancy_name = {
CT_EXAM: 'Экзамен',
CT_CREDIT_GRADE: 'Зачет с оценкой',
CT_CREDIT: 'Зачет',
CT_COURSEWORK: 'Курсовой проект',
}
""" Заполнение раздела 2.2 """
# marker = None
# for p1 in template.get_docx().paragraphs:
# keywords = ['оценочные средства для', 'государственной итоговой аттестации']
# if all(kw in p1.text.lower() for kw in keywords):
# marker = p1
# break
global fileslist
fileslist = [
filename[:-5] for filename in os.listdir('./rpds')
if filename[-4:] == 'docx'
]
plan: EducationPlan = context['plan']
middle[
1] += 'магистратуры' if plan.degree == core.MASTER else 'бакалавриата'
middle[4] += plan.program
middle[3] = plan.code + ' ' + plan.name
subjects = sorted(plan.subject_codes.values(), key=Subject.repr)
for s in subjects:
rpd = difflib.get_close_matches(s.code + ' ' + s.name, fileslist)
if len(rpd) < 1:
continue
rpd = './rpds/' + str(rpd[0]) + '.docx'
rpd_doc = Document(rpd)
# титульная страница
document = template.get_docx()
document.add_page_break()
document.add_paragraph('\n'.join(header))
document.paragraphs[-1].alignment = WD_PARAGRAPH_ALIGNMENT.CENTER
controls = []
for number, semester in s.semesters.items():
controls += [control_fancy_name[c] for c in semester.control]
middle[0] = s.code + ' ' + s.name
middle[6] = ' / '.join(controls)
for ind, line in enumerate(middle):
document.add_paragraph(line)
document.paragraphs[-1].runs[0].bold = middleBold[ind]
document.paragraphs[-1].alignment = WD_PARAGRAPH_ALIGNMENT.CENTER
document.add_paragraph('\n'.join(footer))
document.paragraphs[-1].alignment = WD_PARAGRAPH_ALIGNMENT.CENTER
document.add_page_break()
''' флажок, чтобы забрать все таблицы между двумя группами ключевых слов '''
table_flazhok = False
for table in rpd_doc.tables:
tablen = table2list(table)
if preceding_paragraph(document, ' '.join(tablen[0][:6])):
list2docx(document, *tablen)
''' таблицы все включены, теперь забираем все абзацы '''
text_heap = findout_fos(rpd_doc)
document.add_paragraph(text_heap)
if 'Методические материалы, определяющие' not in text_heap:
document.add_paragraph('\n'.join(method_mater))
def fill_table_6_1(template: DocxTemplate, context: Dict[str, Any]):
""" Заполняем таблицу в разделе 6.1 """
def add_study_results(attr: str, caption: str, row: int, col: int) -> None:
""" Добавить в ячейку таблицы результаты обучения """
results = course.__getattribute__(attr)
if results:
core.set_cell_text(table, row, col, core.JUSTIFY, caption)
for elem in results:
core.set_cell_text(table, row, col, 'Table List', '•\t' + elem)
course, subject = context['course'], context['subject']
# Уровни освоения
control = [s.control for s in subject.semesters.values()]
control = functools.reduce(
lambda x, y: x + y
if isinstance(x, list) else set.union(x, y), control)
if CT_EXAM in control:
levels = [
('Высокий', 'Отлично'),
('Базовый', 'Хорошо'),
('Минимальный', 'Удовлетворительно'),
('Не освоены', 'Неудовлетворительно'),
]
elif CT_CREDIT_GRADE in control:
levels = [
('Высокий', 'Зачтено (отлично)'),
('Базовый', 'Не зачтено (хорошо)'),
('Минимальный', 'Зачтено (удовлетворительно)'),
('Не освоены', 'Не зачтено'),
]
else:
levels = [('Освоено', 'Зачтено'), ('Не освоено', 'Не зачтено')]
# Строки таблицы
table = template.get_docx().tables[8]
rows_count = len(subject.competencies) * len(levels)
core.add_table_rows(table, rows_count)
# Компетенции и индикаторы
start_row = 2
for code in subject.competencies:
competence = context['plan'].competence_codes[code]
table.cell(start_row,
0).merge(table.cell(start_row + len(levels) - 1, 0))
core.set_cell_text(table, start_row, 0, core.JUSTIFY,
competence.code + ' ' + competence.description)
table.cell(start_row,
1).merge(table.cell(start_row + len(levels) - 1, 1))
for ind_code in sorted(competence.indicator_codes):
indicator = competence.indicator_codes[ind_code]
core.set_cell_text(table, start_row, 1, core.JUSTIFY,
ind_code + ' ' + indicator.description)
start_row += len(levels)
# Знать, уметь, владеть
start_row = 2
table.cell(start_row, 2).merge(table.cell(start_row + rows_count - 1, 2))
add_study_results('knowledge', 'Знать:', 2, 2)
add_study_results('abilities', 'Уметь:', 2, 2)
add_study_results('skills', 'Владеть:', 2, 2)
# Уровни освоения
start_row = 2
for level, grade in levels:
table.cell(start_row, 3).merge(
table.cell(start_row + len(subject.competencies) - 1, 3))
core.set_cell_text(table, start_row, 3, core.CENTER, level)
table.cell(start_row, 4).merge(
table.cell(start_row + len(subject.competencies) - 1, 4))
if CT_CREDIT in control:
if level == 'Освоено':
add_study_results('knowledge', 'Обучаемый знает:', start_row,
4)
add_study_results('abilities', 'Обучаемый умеет:', start_row,
4)
add_study_results('skills', 'Обучаемый владеет:', start_row, 4)
else:
add_study_results('knowledge', 'Обучаемый не знает:',
start_row, 4)
add_study_results('abilities', 'Обучаемый не умеет:',
start_row, 4)
add_study_results('skills', 'Обучаемый не владеет:', start_row,
4)
else:
if level == 'Высокий':
add_study_results('knowledge', 'Обучаемый знает:', start_row,
4)
add_study_results('abilities', 'Обучаемый умеет:', start_row,
4)
add_study_results('skills', 'Обучаемый владеет:', start_row, 4)
elif level == 'Базовый':
add_study_results('knowledge', 'Обучаемый знает:', start_row,
4)
add_study_results('abilities', 'Обучаемый не умеет:',
start_row, 4)
add_study_results('skills', 'Обучаемый владеет:', start_row, 4)
elif level == 'Минимальный':
add_study_results('knowledge', 'Обучаемый не знает:',
start_row, 4)
add_study_results('abilities', 'Обучаемый не умеет:',
start_row, 4)
add_study_results('skills', 'Обучаемый владеет:', start_row, 4)
else:
add_study_results('knowledge', 'Обучаемый не знает:',
start_row, 4)
add_study_results('abilities', 'Обучаемый не умеет:',
start_row, 4)
add_study_results('skills', 'Обучаемый не владеет:', start_row,
4)
table.cell(start_row, 5).merge(
table.cell(start_row + len(subject.competencies) - 1, 5))
core.set_cell_text(table, start_row, 5, core.CENTER, grade)
start_row += len(subject.competencies)
core.fix_table_borders(table)
