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 add_week(program_id):
current_program = request.args.get('program')
if not current_program:
current_program = DatabaseManager.get_program(program_id)
if request.method == 'POST':
if not request.form['week_no'] or not request.form['start_date'] or not request.form['end_date']:
flash('Uzupełnij wszystkie dane', 'error')
else:
new_week = Week(week_no=request.form['week_no'],
start_date=DateConverter.to_date(request.form['start_date']),
end_date=DateConverter.to_date(request.form['end_date']), program_id=current_program.id)
if DatabaseManager.add_row(new_week):
return redirect(url_for("program_form", program_id=current_program.id))
return render_template("add_week.html", program_id=program_id, program=current_program)
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 school_form_edit_annex(school_id, annex_id):
if not session.get('program_id'):
return redirect(url_for('program'))
school = DatabaseManager.get_school(school_id)
annex: Contract = DatabaseManager.get_existing_annex(annex_id)
if request.method == 'POST':
date = DateConverter.to_date(request.form['contract_date'])
date_valid = DateConverter.to_date(request.form['validity_date'])
fruitVeg_products = request.form['fruitVeg_products']
dairy_products = request.form['dairy_products']
if annex:
annex.update(date, date_valid, fruitVeg_products, dairy_products)
AnnexCreator(annex.school_id, annex.program_id, annex).generate()
return redirect(url_for('school_form', school_id=school_id))
return render_template("add_annex_form.html", school=school, annex=annex)
def create(self, contract_date=None):
self.contract_date = DateConverter.to_date(contract_date, "%d.%m.%Y")
contract = DatabaseManager.get_contract(self.school.id,
self.program.id)
if contract:
self.contract_no = contract.contract_no
self.contract_year = contract.contract_year
app.logger.warning(
"[%s] Contract already exists [%s, %s]. Only update contract date and regenerate",
__class__.__name__, self.school.nick, self.program.id)
contract.update(self.contract_date)
self.generate()
else:
self.contract_no = str(
DatabaseManager.get_next_contract_no(self.program.id))
self.contract_year = DateConverter.get_year()
app.logger.info(
"[%s] Adding new contract: school_nick %s: city %s | current_date %s, | contract_no %s"
"| contract_year %s", __class__.__name__, self.school.nick,
self.school.city, self.contract_date, self.contract_no,
self.contract_year)
if self.create_new():
self.generate()
else:
app.logger.error(
"[%s] Something went wrong when creating a contract",
__class__.__name__)
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 get_existing_record(current_date, school_id, product_id):
if not product_id:
return None
product_type = Product.query.filter(Product.id == product_id).one().type
cdate = DateConverter.to_date(current_date, pattern=DATABASE_DATE_PATTERN)
assert(product_type == ProductType.DAIRY or product_type == ProductType.FRUIT_VEG)
return Record.query.join(Contract).join(Product).filter(Record.date.like(cdate)).filter(Contract.school_id == school_id)\
.filter(Product.type.like(product_type)).first()
def update(self,
contract_date,
validity_date=None,
fruitVeg_products=None,
dairy_products=None):
self.contract_date = DateConverter.to_date(contract_date)
if validity_date:
self.validity_date = validity_date
if fruitVeg_products:
self.fruitVeg_products = fruitVeg_products
if dairy_products:
self.dairy_products = dairy_products
db.session.commit()
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_contracts(program_id):
current_program = DatabaseManager.get_program(program_id)
contract_date = request.form["contract_date"]
if not is_current_program_set(current_program, config_parser):
flash('Żeby wygenerować umowy ustaw program jako aktulany', 'error')
elif not contract_date or contract_date == "dd.mm.rrrr":
flash('Uzupełnij datę zawarcia umów', 'error')
else:
if session.get('program_id') == program_id:
all_schols = DatabaseManager.get_all_schools()
for school in all_schols:
if school.nick != FILL_STR_SCHOOL: # Dont create contract for school with not full date filled
new_contract = ContractCreator(school, session.get('program_id'))
new_contract.create(DateConverter.to_date(contract_date))
flash("Umowy zostały wygenerowane pomyślnie", 'success')
else:
flash('Możesz wygnerować umowy tylko dla akutalnie wybranego programu', 'error')
return render_template("program_form.html", Program=current_program)
def school_form_add_contract(school_id=INVALID_ID):
if not session.get('program_id'):
return redirect(url_for('program'))
school = DatabaseManager.get_school(school_id)
school_contract = DatabaseManager.get_contract(school_id, session.get('program_id'))
if request.method == 'POST':
date = DateConverter.to_date(request.form['contract_date'])
fruitVeg_products = request.form['fruitVeg_products']
dairy_products = request.form['dairy_products']
if not school_contract:
if not date:
flash('Uzupełnij datę zawarcia umowy', 'error')
else:
new_contract = ContractCreator(school, session.get('program_id'))
new_contract.create(date)
return redirect(url_for('school_form', school_id=school_id))
if school_contract:
school_contract.update(date, date, fruitVeg_products, dairy_products)
return redirect(url_for('school_form', school_id=school_id))
return render_template("add_contract_form.html", school=school, contract=school_contract)
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_daily_records(program_id, current_date, generation_date=None):
cdate = DateConverter.to_date(current_date, pattern=DATABASE_DATE_PATTERN)
gen_date = DateConverter.to_date(generation_date, pattern=DATABASE_DATE_PATTERN) if generation_date else None
if gen_date:
return Record.query.filter(Product.program_id.like(program_id)).filter(Record.date.like(cdate)).filter(Record.generation_date.like(gen_date)).all()
return Record.query.filter(Product.program_id.like(program_id)).filter(Record.date.like(cdate)).all()
def get_week_by_date(date):
rdate = date if isinstance(date, datetime.datetime) else DateConverter.to_date(date, pattern="%Y-%m-%d %H:%M:%S")
return Week.query.filter(Week.start_date <= rdate).filter(Week.end_date >= rdate).first()
def __init__(self, school, sign_date):
super().__init__()
self.school = school
self.sign_date = DateConverter.to_date(sign_date)