def __init__(self, school_id, program_id, existing_annex: Contract = None):
self.program_id = program_id
self.program = DatabaseManager.get_program(program_id)
self.school = DatabaseManager.get_school(school_id)
if not existing_annex:
self.contract = DatabaseManager.get_contract(
school_id, self.program_id)
self.contract_no = "{0}_{1}".format(
self.contract.contract_no,
DatabaseManager.get_next_annex_no(school_id, self.program_id))
self.contract_year = self.contract.contract_year
self.contract_date = None
self.validity_date = None
self.fruitVeg_products = None
self.dairy_products = None
else:
self.contract = existing_annex
self.contract_no = existing_annex.contract_no
self.contract_year = existing_annex.contract_year
self.contract_date = existing_annex.contract_date
self.validity_date = existing_annex.validity_date
self.fruitVeg_products = existing_annex.fruitVeg_products
self.dairy_products = existing_annex.dairy_products
output_directory = self.school.generate_directory_name(
config_parser.get('Directories', 'annex'))
DocumentCreator.__init__(self,
config_parser.get('DocTemplates', 'annex'),
output_directory)
DatabaseManager.__init__(self)
def __init__(self, program_id):
self.date = datetime.today().strftime('%d-%m-%Y')
self.program = DatabaseManager.get_program(program_id)
self.contracts = DatabaseManager.get_contracts(program_id)
self.program_semester = self.program.get_current_semester()
self.year = self.program.school_year
self.records_to_merge = []
output_directory = config_parser.get('Directories', 'current_program')
DocumentCreator.__init__(self,
config_parser.get('DocTemplates', 'register'),
output_directory)
def __init__(self, program_id, weeks: Set[int], no=None):
self.summary: Summary = None
self.program_id = program_id
self.weeks = weeks
if no:
self.summary = DatabaseManager.get_summary(self.program_id, no)
self.summary.weeks = weeks
DatabaseManager.modify()
self.school_no = 0
output_directory = config_parser.get('Directories', 'current_program')
DocumentCreator.__init__(self, config_parser.get('DocTemplates', 'summary'), output_directory)
DatabaseManager.__init__(self)
def generate_many(records_to_merge, file_prefix=None):
if not records_to_merge:
return
out_dir = config_parser.get('Directories', 'record_all')
doc = DocumentCreator.start_doc_gen(
config_parser.get('DocTemplates', 'record'), out_dir)
records_to_merge_list = [
record.doc_data for record in records_to_merge
if (isinstance(record, RecordCreator) and record.doc_data)
]
if not records_to_merge_list:
return
date = records_to_merge[0].date
if not isinstance(date, datetime.date):
date = DateConverter.to_date(date)
gen_date = records_to_merge[0].generation_date
if not isinstance(gen_date, datetime.date):
gen_date = DateConverter.to_date(gen_date)
assert (gen_date and date) # @TODO remove later
if not gen_date or not date:
return
out_dir = path.join(out_dir,
DateConverter.to_string(gen_date, '%Y_%m_%d'),
DateConverter.to_string(date))
if not path.exists(out_dir):
makedirs(out_dir)
out_file_name = ALL_RECORDS_DOC_NAME
if file_prefix and file_prefix != ALL_RECORDS_DOC_NAME:
counter = 1
for filename in listdir(out_dir):
if file_prefix in filename:
counter += 1
out_file_name = "{}_{}{}".format(out_file_name, file_prefix,
counter)
out_doc = path.join(out_dir, "{}.docx".format(out_file_name))
doc.merge_pages(records_to_merge_list)
app.logger.info("[%s] Created merge docx of records in dir: [%s]",
RecordCreator.__qualname__, out_doc)
DocumentCreator.end_doc_gen(doc, out_doc, out_dir, gen_pdf=True)
def __init__(self, school, program_id, ommit_representat=True):
self.main_contract_dir = config_parser.get('Directories',
'contract_all')
if not path.exists(self.main_contract_dir):
makedirs(self.main_contract_dir)
self.program = DatabaseManager.get_program(program_id)
self.school = school
self.contract_no = None
self.contract_year = None
self.contract_date = None
self.ommit_representat = ommit_representat
output_directory = self.school.generate_directory_name(
config_parser.get('Directories', 'contract'))
DocumentCreator.__init__(self,
config_parser.get('DocTemplates', 'contract'),
output_directory)
DatabaseManager.__init__(self)
def __init__(self, template_document, output_directory):
if not path.exists(template_document):
app.logger.error("[%s] template document: %s does not exists", __class__.__name__, template_document)
self.document = DocumentCreator.start_doc_gen(template_document, output_directory)
self.fields_to_merge = self.document.get_merge_fields()
if config_parser.get('Common', 'debug_on'):
app.logger.info("[%s] merge fields: %s", __class__.__name__, self.fields_to_merge)
self.template_document = template_document
self.output_directory = output_directory
super(DocumentCreator, self).__init__()
def __init__(self, program_id, school, summary, date):
self.template_document_v = config_parser.get('DocTemplates',
'application')
self.template_document_va = config_parser.get('DocTemplates',
'application_5a')
self.main_app_dir = path.join(
config_parser.get('Directories', 'application_all'),
str(summary.no))
if not path.exists(self.main_app_dir):
makedirs(self.main_app_dir)
self.program_id = program_id
self.school: School = school
self.summary: Summary = summary
self.default_data: DefaultData = DefaultData(self.school, date)
self.common_data: CommonData = CommonData(self.program_id,
self.school.id,
self.summary.weeks)
self.fruits = Fruit(self.common_data)
self.vegs = Veg(self.common_data)
self.dairy = Dairy(self.common_data)
self.frutiVeg = FruitVegSummary(self.common_data)
self.dairySummary = DairySummary(self.common_data)
self.tmp_data_to_rename = list([
self.default_data, self.common_data, self.fruits, self.vegs,
self.dairy, self.frutiVeg, self.dairySummary
])
self.output_directory = self.school.generate_directory_name(
config_parser.get('Directories', 'application'))
self.product_data = dict()
self.inconsistent_records_error = None
if not self.__prepare_data():
raise Exception("Cannot prepare data")
DatabaseManager.__init__(self)
def __init__(self,
program_id,
current_date,
school_id,
product_id,
generation_date=""):
self.program_id = program_id
self.date = DateConverter.to_date(current_date,
pattern=DATABASE_DATE_PATTERN)
self.state = RecordState.NOT_DELIVERED
self.contract = DatabaseManager.get_current_contract(
school_id, self.program_id, self.date)
self.product = DatabaseManager.get_product(product_id)
self.doc_data = dict()
self.generation_date = DateConverter.to_date(
generation_date) if generation_date else datetime.date.today()
output_directory = self.contract.school.generate_directory_name(
config_parser.get('Directories', 'record'))
DocumentCreator.__init__(self,
config_parser.get('DocTemplates', 'record'),
output_directory)
DatabaseManager.__init__(self)
self._prepare_data_for_doc()
def generate(self):
self.document.merge(
city=self.school.city,
current_date=self.contract_date.strftime("%d.%m.%Y"),
contract_no=str(self.contract_no.split("_")[0]),
contract_year=str(self.contract_year),
semester_no=self.program.get_current_semester(),
school_year=self.program.school_year,
name=self.school.name,
address=self.school.address,
nip=self.school.nip,
regon=self.school.regon,
responsible_person=self.school.responsible_person,
fruitveg_products=str(self.fruitVeg_products),
dairy_products=str(self.dairy_products),
validity_date=self.validity_date.strftime("%d.%m.%Y"))
created_annex = DocumentCreator.generate(
self, "Aneks_" + self.contract_date.strftime("%d_%m_%Y") + ".docx")
new_annex_dst = path.join(
config_parser.get('Directories', 'annex_all'),
"{0}_Aneks_{1}_{2}.docx".format(self.school.nick, self.contract_no,
self.contract_year))
DocumentCreator.copy_to_path(created_annex, new_annex_dst)
class DocumentCreator(ABC):
wdFormatPDF = 17
pdf_converter = path.normpath(config_parser.get('Common', 'libreoffice_converter_path'))
def __init__(self, template_document, output_directory):
if not path.exists(template_document):
app.logger.error("[%s] template document: %s does not exists", __class__.__name__, template_document)
self.document = DocumentCreator.start_doc_gen(template_document, output_directory)
self.fields_to_merge = self.document.get_merge_fields()
if config_parser.get('Common', 'debug_on'):
app.logger.info("[%s] merge fields: %s", __class__.__name__, self.fields_to_merge)
self.template_document = template_document
self.output_directory = output_directory
super(DocumentCreator, self).__init__()
@abstractmethod
def generate(self, new_doc_name, gen_pdf=True): #@TODO fix this method for generating pdfs
generated_file = path.join(self.output_directory, new_doc_name)
res = DocumentCreator.end_doc_gen(self.document, generated_file, self.output_directory, gen_pdf) #TODO: pdf are not genereting correctly for 5
if res:
return generated_file
# elif res:
# DocumentCreator.print_pdf(generated_file)
# return generated_file
return None #@TODO create exception here and return the ProperException
@staticmethod
def copy_to_path(source, dest):
old_file_name = path.basename(source)
new_file_name = path.basename(dest)
new_dst = path.dirname(dest)
if not path.exists(new_dst):
makedirs(new_dst)
if source:
if path.exists(path.join(dest)):
remove(path.join(dest))
copy(source, new_dst)
rename(path.join(new_dst, old_file_name), path.join(new_dst, new_file_name))
def generate_many(self):
pass
def generate_rows(self):
pass
@staticmethod
def generate_pdf(docx_to_convert, output_dir):
try:
docx_to_convert = path.normpath(docx_to_convert)
output_dir = path.normpath(output_dir)
app.logger.info(f"Generate pdf for {docx_to_convert} using {DocumentCreator.pdf_converter} save in {output_dir}")
args = [DocumentCreator.pdf_converter, '--headless', '--convert-to', 'pdf', '--outdir', output_dir, docx_to_convert]
subprocess.run(args, stdout=subprocess.PIPE, stderr=subprocess.PIPE, timeout=3000)
except Exception as e:
app.logger.error("[%s] Serious error when generating pdf from docx %s out_dir %s: err_msg: %s. Check libreoffice converter path: %s",
__class__.__name__, docx_to_convert, output_dir , e, DocumentCreator.pdf_converter,)
@staticmethod
def print_pdf(filename):
pass
#win32api.ShellExecute(0, 'open', 'gsprint.exe',
# '-printer "\\\\' + self.server + '\\' + self.printer_name + '" ' + file, '.', 0)
@staticmethod
def create_directory(output_directory):
if not path.exists(output_directory):
makedirs(output_directory)
app.logger.info("[%s] Created new output directory: %s", __class__.__name__, output_directory)
@staticmethod
def start_doc_gen(doc_template, output_dir):
DocumentCreator.create_directory(output_dir)
return MailMerge(doc_template)
@staticmethod
def end_doc_gen(document, generated_file, output_dir, gen_pdf=True):
document.write(generated_file)
app.logger.info("[%s] Created new output directory: %s", __class__.__name__, generated_file, )
if gen_pdf:
DocumentCreator.generate_pdf(generated_file, output_dir)
return True
@abstractmethod
def create(self):
pass
def get_current_summaries(current_program_id):
return [summary for summary in DatabaseManager.get_summaries(current_program_id) if
summary.no in parse_special_string_format_to_set(config_parser.get("Program", "summary"))]
def is_current_program_set(current_program, config_parser):
return current_program.school_year != FILL_STR and str(config_parser.get("Program", "year")) == str(current_program.school_year.replace("/", "_")) and int(
config_parser.get("Program", "semester")) == int(current_program.semester_no)
def update_summary_list_based_on_config_file(new_summary_no):
set_of_summaries = parse_special_string_format_to_set(config_parser.get('Program', 'summary'))
set_of_summaries.add(new_summary_no)
update_summary_list(set_of_summaries)
def generate_directory_name(self, specific_directory):
return path.join(config_parser.get('Directories', 'school'), self.nick,
specific_directory)
def prepare_per_week(self, base_name, fun):
for week in range(1, int(config_parser.get('Program', 'weeks')) + 1):
self.dict_data[f"{base_name}{week}"] = fun(
self.weeks[week]) if week in self.weeks.keys() else None
