from flask import render_template
import os
import subprocess
import shutil
from models.database import Document, Protocol, Error, Todo, Decision
from server import celery, app
from shared import db, escape_tex, unhyphen, date_filter, datetime_filter, date_filter_long, time_filter
from utils import mail_manager, url_manager, encode_kwargs, decode_kwargs
from parser import parse, ParserException, Element, Content, Text, Tag, Remark, Fork
import config
texenv = app.create_jinja_environment()
texenv.block_start_string = r"\ENV{"
texenv.block_end_string = r"}"
texenv.variable_start_string = r"\VAR{"
texenv.variable_end_string = r"}"
texenv.comment_start_string = r"\COMMENT{"
texenv.comment_end_string = r"}"
texenv.filters["escape_tex"] = escape_tex
texenv.filters["unhyphen"] = unhyphen
texenv.trim_blocks = True
texenv.lstrip_blocks = True
texenv.filters["url_complete"] = url_manager.complete
texenv.filters["datify"] = date_filter
texenv.filters["datify_long"] = date_filter_long
texenv.filters["datetimify"] = datetime_filter
texenv.filters["timify"] = time_filter
mailenv = app.create_jinja_environment()
mailenv.trim_blocks = True
mailenv.lstrip_blocks = True
mailenv.filters["url_complete"] = url_manager.complete
mailenv.filters["datify"] = date_filter
mailenv.filters["datetimify"] = datetime_filter
ID_FIELD_BEGINNING = "id "
def parse_protocol(protocol, **kwargs):
parse_protocol_async.delay(protocol.id, encode_kwargs(kwargs))
@celery.task
def parse_protocol_async(protocol_id, encoded_kwargs):
with app.app_context():
with app.test_request_context("/"):
kwargs = decode_kwargs(encoded_kwargs)
protocol = Protocol.query.filter_by(id=protocol_id).first()
if protocol is None:
raise Exception("No protocol given. Aborting parsing.")
if protocol.source is None:
error = protocol.create_error("Parsing", "Protocol source is None", "")
db.session.add(error)
db.session.commit()
return
tree = None
try:
tree = parse(protocol.source)
except ParserException as exc:
context = ""
if exc.linenumber is not None:
source_lines = source.splitlines()
start_index = max(0, exc.linenumber - config.ERROR_CONTEXT_LINES)
end_index = min(len(source_lines) - 1, exc.linenumber + config.ERROR_CONTEXT_LINES)
context = "\n".join(source_lines[start_index:end_index])
error = protocol.create_error("Parsing", str(exc), context)
db.session.add(error)
db.session.commit()
return
remarks = {element.name: element for element in tree.children is isinstance(element, Remark)}
required_fields = ["Datum", "Anwesende", "Beginn", "Ende", "Autor", "Ort"]
missing_fields = [field for field in required_files if field not in remarks]
if len(missing_fields) > 0:
error = protocol.create_error("Parsing", "Missing fields", ", ".join(missing_fields))
db.session.add(error)
db.session.commit()
return
try:
protocol.fill_from_remarks(remarks)
except ValueError:
error = protocol.create_error(
"Parsing", "Invalid fields",
"Date or time fields are not '%d.%m.%Y' respectively '%H:%M', "
"but rather {}".format(
", ".join([remarks["Datum"], remarks["Beginn"], remarks["Ende"]])))
db.session.add(error)
db.session.commit()
return
old_todos = list(protocol.todos)
for todo in old_todos:
protocol.todos.remove(todo)
db.session.commit()
tags = tree.get_tags()
todo_tags = [tag for tag in tags if tag.name == "todo"]
for todo_tag in todo_tags:
if len(todo_tag.values) < 2:
error = protocol.create_error("Parsing", "Invalid todo-tag",
"The todo tag in line {} needs at least "
"information on who and what, "
"but has less than that.".format(todo_tag.linenumber))
db.session.add(error)
db.session.commit()
return
who = todo_tag.values[0]
what = todo_tag.values[1]
todo = None
for other_field in todo_tag.values[2:]:
if other_field.startswith(ID_FIELD_BEGINNING):
field_id = 0
try:
field_id = int(other_field[len(ID_FIELD_BEGINNING):])
except ValueError:
error = protocol.create_error("Parsing", "Non-numerical todo ID",
"The todo in line {} has a nonnumerical ID, but needs "
"something like \"id 1234\"".format(todo_tag.linenumber))
db.session.add(error)
db.session.commit()
return
todo = Todo.query.filter_by(id=field_id).first()
if todo is None:
todo = Todo(who=who, description=what, tags="", done=False)
db.session.add(todo)
todo.protocols.append(protocol)
todo_tags_internal = todo.tags.split(";")
for other_field in todo_tag.values[2:]:
if other_field.startswith(ID_FIELD_BEGINNING):
continue
elif other_field == "done":
todo.done = True
elif other_field not in todo_tags_internal:
todo_tags_internal.append(other_field)
todo.tags = ";".join(todo_tags_internal)
db.session.commit()
old_decisions = list(protocol.decisions)
for decision in old_decisions:
protocol.decisions.remove(decision)
db.session.commit()
decision_tags = [tag for tag in tags if tag.name == "beschluss"]
for decision_tag in decision_tags:
if len(decision_tag.values) == 0:
error = protocol.create_error("Parsing", "Empty decision found.",
"The decision in line {} is empty.".format(decision_tag.linenumber))
db.session.add(error)
db.session.commit()
return
decision = Decision(protocol_id=protocol.id, content=decision_tag.values[0])
db.session.add(decision)
db.session.commit()
@celery.task
def compile_async(name, document_id):
is_error = False
try:
current = os.getcwd()
os.chdir("latex")
os.makedirs("bin", exist_ok=True)
command = [
"/usr/bin/xelatex",
"-halt-on-error",
"-file-line-error",
"-output-directory", "bin",
"{}.tex".format(name)
]
subprocess.check_call(command, universal_newlines=True, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
subprocess.check_call(command, universal_newlines=True, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
os.chdir(current)
os.makedirs("documents/pdf", exist_ok=True)
shutil.copy("latex/bin/{}.pdf".format(name), "documents/pdf/")
for typ in ["pdf", "log", "aux", "out"]:
silent_remove("latex/bin/{}.{}".format(name, typ))
silent_remove("latex/{}.tex".format(name))
except subprocess.SubprocessError:
is_error = True
with app.app_context():
document = Document.query.filter_by(id=document_id).first()
if document is not None:
document.ready = False
document.error = True
db.session.commit()
finally:
# TODO: activate deleting files in error case too
#for typ in ["pdf", "log", "aux", "out"]:
# silent_remove("latex/bin/{}.{}".format(name, typ))
#silent_remove("latex/{}.tex".format(name))
os.chdir(current)
if not is_error:
with app.app_context():
document = Document.query.filter_by(id=document_id).first()
if document is not None:
document.ready = True
db.session.commit()
def send_mail(mail):
send_mail_async.delay(mail.id)
@celery.task
def send_mail_async(mail_id):
with app.app_context():
mail = Mail.query.filter_by(id=mail_id).first()
if mail is None:
return False
mail.ready = False
mail.error = False
db.session.commit()
result = mail_manager.send(mail.to_addr, mail.subject, mail.content)
mail.ready = True
mail.error = not result
db.session.commit()