def _preapre_str_from_weeks(weeks):
return ",".join([
"{0}-{1}".format(
DateConverter.to_string(week.start_date, "%d.%m"),
DateConverter.to_string(week.end_date, "%d.%m.%Y"))
for week in weeks
])
def fill_data_in_table(self, contract, no, is_annex):
record_dict = dict()
if not is_annex:
record_dict['no'] = str(no)
record_dict['contract_info'] = "{}/{}".format(
contract.contract_no, contract.contract_year)
record_dict['school_name'] = contract.school.name
record_dict['school_nip'] = contract.school.nip
record_dict['school_address'] = contract.school.address
record_dict['school_city'] = contract.school.city
record_dict['school_regon'] = contract.school.regon
record_dict['school_phone'] = contract.school.phone
record_dict['school_email'] = contract.school.email
else:
record_dict['no'] = RegisterCreator.CELL_TO_MERGE_MARK
record_dict['school_name'] = RegisterCreator.CELL_TO_MERGE_MARK
record_dict['school_nip'] = RegisterCreator.CELL_TO_MERGE_MARK
record_dict['school_address'] = RegisterCreator.CELL_TO_MERGE_MARK
record_dict['school_city'] = RegisterCreator.CELL_TO_MERGE_MARK
record_dict['school_regon'] = RegisterCreator.CELL_TO_MERGE_MARK
record_dict['school_phone'] = RegisterCreator.CELL_TO_MERGE_MARK
record_dict['school_email'] = RegisterCreator.CELL_TO_MERGE_MARK
validity_date = DateConverter.to_date(contract.validity_date)
record_dict['contract_info'] = "{}/{}".format(
contract.contract_no.split("_")[0], contract.contract_year)
record_dict['annex_info'] = "{}*".format(
DateConverter.to_string(validity_date, "%d-%m-%Y"))
record_dict['kids_milk'] = str(contract.dairy_products)
record_dict['kids_fruitveg'] = str(contract.fruitVeg_products)
self.records_to_merge.append(record_dict)
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 _prepare_data_for_doc(self):
self.doc_data['city'] = self.contract.school.city
self.doc_data['current_date'] = DateConverter.to_string(self.date)
self.doc_data['name'] = self.contract.school.name
self.doc_data['address'] = self.contract.school.address
self.doc_data['nip'] = self.contract.school.nip
self.doc_data['regon'] = self.contract.school.regon
self.doc_data['email'] = self.contract.school.email
self.doc_data['kids_no'] = str(self._get_kids_no())
self.doc_data['product_name'] = self.product.get_name_mapping()
self.doc_data['record_title'] = self.product.get_record_title_mapping()
def generate(self):
self.document.merge(
city=self.school.city,
date=DateConverter.to_string(self.contract_date, "%d.%m.%Y"),
no=str(self.contract_no),
year=str(self.contract_year),
semester=self.program.get_current_semester(),
name=self.school.name,
address=self.school.address,
nip=self.school.nip,
regon=self.school.regon,
representant=self.school.responsible_person
if not self.ommit_representat else FILL_BY_SCHOOL,
email=self.school.email,
program_start_date=DateConverter.to_string(self.program.start_date,
"%d.%m.%Y"),
program_end_date=DateConverter.to_string(self.program.end_date,
"%d.%m.%Y"),
nip_additional=self.school.representative_nip
if self.school.representative_nip else "-",
name_additional=self.school.representative
if self.school.representative else "-",
regon_additional=self.school.representative_regon
if self.school.representative_regon else "-",
giving_weeks=ContractCreator._preapre_str_from_weeks(
DatabaseManager.get_weeks(self.program.id)))
doc_contract_name = "Umowa_{0}_{1}.docx".format(
self.contract_no, self.contract_year)
created_doc_name = DocumentCreator.generate(self, doc_contract_name)
doc_contract_name_copy = path.join(
self.main_contract_dir,
"{0}_Umowa_{1}_{2}.docx".format(self.school.nick, self.contract_no,
self.contract_year))
try:
DocumentCreator.copy_to_path(created_doc_name,
doc_contract_name_copy)
# DocumentCreator.copy_to_path(created_doc_name.replace("docx", "pdf"), doc_contract_name_copy.replace("docx", "pdf")) #TODO problem with generating pdf numbering is wrong
except:
app.logger.error("Could not copy files [%s]", created_doc_name)
def program_form(program_id=INVALID_ID):
config_parser.read(config_file)
if program_id == INVALID_ID:
id_of_program_being_added = DatabaseManager.id_of_program_being_added(FILL_STR)
if not id_of_program_being_added:
default_date = DateConverter.to_string(datetime.datetime.now())
new_program = Program(semester_no=FILL_STR, school_year=FILL_STR, fruitVeg_price=FILL_STR,
dairy_price=FILL_STR, start_date=DateConverter.to_date(default_date),
end_date=DateConverter.to_date(default_date),
dairy_min_per_week=FILL_STR, fruitVeg_min_per_week=FILL_STR, dairy_amount=FILL_STR,
fruitVeg_amount=FILL_STR)
if DatabaseManager.add_row(new_program):
return redirect(url_for('program_form', program_id=new_program.id))
else:
return redirect(url_for('program_form', program_id=INVALID_ID))
else:
return redirect(url_for('program_form', program_id=id_of_program_being_added.id))
current_program = DatabaseManager.get_program(program_id)
school_without_summary = None
summaries_data = None
if is_current_program_set(current_program, config_parser):
schools_with_contract = DatabaseManager.get_all_schools_with_contract(current_program.id)
available_summary = get_current_summaries(current_program.id)
summaries_data = dict()
if not available_summary:
school_without_summary = schools_with_contract
else:
school_without_summary = [school for school in schools_with_contract
if not any(
[DatabaseManager.get_application(school.id, summary.id) for summary in available_summary])]
summaries_data = {
k: ", ".join(
[application.school.nick for application in DatabaseManager.get_school_with_summary(k.id) if
application.school])
for k in available_summary}
if request.method == 'POST':
data_to_update = {"semester_no": empty_if_none(request.form["semester_no"]),
"school_year": empty_if_none(request.form["school_year"]),
"fruitVeg_price": empty_if_none(request.form["fruitVeg_price"]),
"dairy_price": empty_if_none(request.form["dairy_price"]),
"start_date": empty_if_none(DateConverter.to_date(request.form["start_date"])),
"end_date": empty_if_none(DateConverter.to_date(request.form["end_date"])),
"dairy_min_per_week": empty_if_none(request.form["dairy_min_per_week"]),
"fruitVeg_min_per_week": empty_if_none(request.form["fruitVeg_min_per_week"]),
"dairy_amount": empty_if_none(request.form["dairy_amount"]),
"fruitVeg_amount": empty_if_none(request.form["fruitVeg_amount"])}
program_id = DatabaseManager.update_program_data(current_program, **data_to_update)
return redirect(url_for('program_form', program_id=program_id))
return render_template("program_form.html", Program=current_program, Schools=school_without_summary,
Summary=summaries_data)
def generate(self):
self.document.merge(city=self.doc_data['city'],
current_date=self.doc_data['current_date'],
name=self.doc_data['name'],
address=self.doc_data['address'],
nip=self.doc_data['nip'],
regon=self.doc_data['regon'],
email=self.doc_data['email'],
kids_no=self.doc_data['kids_no'],
product_name=self.doc_data['product_name'],
record_title=self.doc_data['record_title'])
DocumentCreator.generate(self,
"WZ_{0}_{1}.docx".format(
DateConverter.to_string(self.date),
self.product.get_type_mapping()),
gen_pdf=True)
def convert_start_end_to_string(self):
return DateConverter.to_string(self.end_date)
def convert_start_date_to_string(self):
return DateConverter.to_string(self.start_date)
def convert_validity_date_to_string(self):
return DateConverter.to_string(self.validity_date)
def convert_date_to_string(self):
return DateConverter.to_string(self.contract_date)
def contract_date(self):
if self.contracts:
return DateConverter.to_string(self.contracts[0].contract_date)
else:
return DateConverter.to_string(datetime.datetime.now())
def is_annex(validity_date, school_id, program_id):
rdate = validity_date if not isinstance(validity_date, datetime.datetime) else DateConverter.to_string(validity_date)
return Contract.query.join(Contract.school).filter(Contract.program_id == program_id).filter(School.id==school_id)\
.filter(Contract.validity_date == DateConverter.to_date(rdate)).all()
def get_dates(program_id, week_no):
week = Week.query.filter(Week.program_id==program_id).filter(Week.week_no==week_no).one()
return "{0}-{1}\n{2}".format(DateConverter.to_string(week.start_date, "%d.%m"),
DateConverter.to_string(week.end_date, "%d.%m"),
DateConverter.to_string(week.end_date, "%Y"))
def __prepare_data(self):
try:
self.__are_records_inconsistent()
except InconsistentAnnexWzError as e:
self.inconsistent_records_error = f"Szkoła: {self.school.nick}.\n{e}", e.get_log_level(
)
for data in self.tmp_data_to_rename:
data.prepare()
self.product_data.update(self.fruits.get())
self.product_data.update(self.vegs.get())
self.product_data.update(self.dairy.get())
self.product_data[
'max_kids_perWeeks_fruitVeg'] = self.frutiVeg.get_kids()
self.product_data[
'max_kids_perWeeks_milk'] = self.dairySummary.get_kids()
self.__prepare_fruit_data()
self.__prepare_dairy_data()
for record in DatabaseManager.get_records(self.program_id,
self.school.id,
ProductType.FRUIT_VEG,
self.summary.weeks):
record_dict = dict()
record_dict['date_vegFruit'] = DateConverter.to_string(
record.date, "%d.%m.%Y")
record_dict['kids_vegFruit'] = str(record.product_no)
record_dict['vegFruit'] = record.Product.get_name_mapping()
self.records_to_merge_vegFruit.append(record_dict)
for record in DatabaseManager.get_records(self.program_id,
self.school.id,
ProductType.DAIRY,
self.summary.weeks):
record_dict = dict()
record_dict['date_milk'] = DateConverter.to_string(
record.date, "%d.%m.%Y")
record_dict['kids_milk'] = str(record.product_no)
record_dict['milk'] = record.Product.get_name_mapping()
self.records_to_merge_milk.append(record_dict)
self.sum_product_vegFruit = self.__sum_product(
self.records_to_merge_vegFruit, 'kids_vegFruit')
self.sum_product_milk = self.__sum_product(self.records_to_merge_milk,
'kids_milk')
fruit_veg = self.product_data['veg_all'] + self.product_data[
'fruit_all']
if self.sum_product_vegFruit != fruit_veg:
app.logger.error(
"Value of fruitVeg product from 5 and 5A does not match! School: {0} 5: {1} "
" 5A: {2} -- ABORT generating".format(
self.school.nick, fruit_veg, self.sum_product_vegFruit))
return False
if self.sum_product_milk != self.product_data['dairy_all']:
app.logger.error(
"Value of dairy product from 5 and 5A does not match! School: {0} 5: {1} "
" 5A: {2} -- ABORT generating".format(
self.school.nick, self.product_data['dairy_all'],
self.sum_product_milk))
return False
return True