def create_new_unaccepted_version(data):
"""
Creates unaccepted version of existing schedule
:param data: json with all information for every individual schedule
"""
if acc_test.check_access(1) is False:
return redirect(url_for("main.index"))
unaccepted_schedule = Schedule.query.filter_by(
name="%s-%s-%s" % (data["main_data"]["year"], data["main_data"]["month"],
data["main_data"]["workplace"]), accepted=False).first()
name = unaccepted_schedule.name
year = unaccepted_schedule.year
month = unaccepted_schedule.month
workplace = unaccepted_schedule.workplace
hours = unaccepted_schedule.hrs_to_work
accepted = True
version = unaccepted_schedule.version + 1
billing_period = unaccepted_schedule.billing_period
schedule = Schedule(name=name, year=year, month=month, workplace=workplace, hrs_to_work=hours,
accepted=accepted, version=version, billing_period=billing_period)
db.session.add(schedule)
ind_schedules_to_db(data, schedule, billing_period)
db.session.commit()
for ind_schedule in unaccepted_schedule.ind:
db.session.delete(ind_schedule)
db.session.delete(unaccepted_schedule)
db.session.commit()
def billing_period():
"""
Allows to set beginning of counting billing periods and length of it in months.
"""
if acc_test.check_access(0) is False:
return redirect(url_for("main.index"))
form = BillingPeriod()
cur_begin = "{: %d - %m - %Y}".format(
Billing_period.query.filter_by(id=1).first().begin)
cur_duration = Billing_period.query.filter_by(id=1).first().duration
if form.validate_on_submit():
begin = datetime(int(form.begin_year.data), int(form.begin_month.data),
1)
duration = form.length_of_billing_period.data
b_p = Billing_period
b_p.query.filter_by(id=1).all()[0].begin = begin
b_p.query.filter_by(id=1).all()[0].duration = duration
db.session.commit()
flash("Zmieniono okres rozliczeniowy na: Początek: %s Długość: %s" %
("{:%d - %m - %Y}".format(begin), duration))
return redirect(url_for("main.index"))
return render_template("billing_period/billing_period.html",
title="Grafiki - okres rozliczeniowy",
form=form,
cur_begin=cur_begin,
cur_duration=cur_duration)
def worker_to_workplace():
"""
Allows to manage connections between workers and workplaces.
"""
if acc_test.check_access(0) is False:
return redirect(url_for("main.index"))
form = UserToShopForm()
assign_worker(form)
workplaces = Shop.query.order_by(Shop.shopname).all()
if form.validate_on_submit():
worker = User.query.filter_by(username=form.worker.data).first()
workplace = Shop.query.filter_by(shopname=form.workplace.data).first()
already_assigned = workplace.works
if worker not in already_assigned:
workplace.works.append(worker)
db.session.commit()
flash("Przypisano %s do %s" % (worker, workplace))
else:
flash("%s był już przypisany do %s" % (worker, workplace))
return redirect(url_for("acc.worker_to_workplace"))
return render_template(
"acc_man/worker_to_workplace.html",
title="Grafiki - przydzielanie użytkownika do sklepu",
form=form,
workplaces=workplaces)
def remove_schedule(schedule):
"""
Removes schedule with passed id from db.
:param schedule: schedule's id
"""
if acc_test.check_access(2) is False:
return redirect(url_for("main.index"))
return remove_sched.remove_sched(schedule)
def guidelines_to_db():
"""
Adds records with guidelines to db.
"""
if acc_test.check_access(1) is False:
return redirect(url_for("main.index"))
guideline_to_database.add_guideline()
return url_for("main.index")
def modifiable_schedules():
"""
Makes list of schedules modifiable by current user.
:return: renders template with form that allows to filter all accepted schedules and chose one to modify
"""
if acc_test.check_access(2) is False:
return redirect(url_for("main.index"))
return render_template("schedules/schedules-to-modify.html",
title="Grafiki - modyfikowalne grafiki",
mn=MONTH_NAMES,
Schedule=Schedule)
def new_schedule_find_workers(workplace):
"""
Finds workers assigned to chosen workplace and sends back list with them to template that allow to choose workers
that will be in schedule.
:param workplace: chosen workplace
:return: jsonified list of workers assigned to chosen workplace
"""
if acc_test.check_access(2) is False:
return redirect(url_for("main.index"))
jsondict = find_workers.find_workers(workplace)
return jsonify({"workers": jsondict})
def new_schedule_to_db(action):
"""
Adds new (unaccepted) schedule do database or replaces unaccepted version with accepted one.
:param action: tells function if it has to add new version to db or replace existing one with it's accepted version.
"""
if acc_test.check_access(2) is False:
return redirect(url_for("main.index"))
data = request.json
new_schd_to_db.add_schedule_to_db(action, data)
return url_for("main.index")
def filter_schedules_to_modify(year, month, workplace, action):
"""
Finds schedule that matches filter criteria.
:param year: year of schedule
:param month: month of schedule
:param workplace: workplace of schedule
:param action: action to take
:return: matching schedule
"""
if acc_test.check_access(2) is False:
return redirect(url_for("main.index"))
return jsonify(
filter_sched_to_modify.find_schedule(year, month, workplace, action))
def unaccepted_schedules():
"""
:return: shows list of every unaccepted schedules which current user can accept.
"""
if acc_test.check_access(1) is False:
return redirect(url_for("main.index"))
los = list_of_schedules.list_of_schedules_acc_mod(mod_acc=False)
return render_template("schedules/schedules-to-accept.html",
title="Grafiki - niezaakceptowane grafiki",
ua=los["schedules"],
sn=los["nos"],
Schedule=Schedule)
def remove_from_shop():
"""
Removes link between worker and workplace.
"""
if acc_test.check_access(0) is False:
return redirect(url_for("main.index"))
user = request.args.get("user")
workplace = request.args.get("workplace")
found_user = User.query.filter_by(username=user).first()
found_workplace = Shop.query.filter_by(shopname=workplace).first()
found_workplace.works.remove(found_user)
db.session.commit()
flash("Usunięto %s z %s" % (user, workplace))
return redirect(url_for("acc.worker_to_workplace"))
def show_changes(sch_id):
"""
Shows changes between last accepted and unaccepted version of schedule.
:param sch_id: id of unaccepted schedule
:return: renders template with changes
"""
if acc_test.check_access(1) is False:
return redirect(url_for("main.index"))
changes = None
schedule_id = sch_id
schedule = Schedule.query.filter_by(id=schedule_id).first()
if schedule.version > 0:
changes = differences.get_diff(schedule_id)
return render_template("schedules/changes.html", changes=changes)
def new_workplace():
"""
Adds new workplace to database.
"""
if acc_test.check_access(0) is False:
return redirect(url_for("main.index"))
form = NewWorkplaceForm()
if form.validate_on_submit():
workplace = Shop(shopname=form.workplace_name.data)
db.session.add(workplace)
db.session.commit()
flash("Stworzono nowy sklep")
return redirect(url_for("main.index"))
return render_template("acc_man/new_workplace.html",
title="Grafiki - nowy sklep",
form=form)
def new_schedule():
"""
Creates template with empty, modifiable schedule for chosen year, month and workplace and with unmodifiable
schedule for previous month.
:return: template with all necessary data for new schedule
"""
if acc_test.check_access(2) is False:
return redirect(url_for("main.index"))
form = NewScheduleForm()
new_schedule_funcs.ns_choices(form)
if form.validate_on_submit():
return new_schedule_funcs.ns_form_validate(form)
return render_template("schedules/new_schedule.html",
title="Grafiki - nowy grafik",
form=form)
def new_user():
"""
Adds new user to database.
"""
if acc_test.check_access(0) is False:
return redirect(url_for("main.index"))
form = NewUserForm()
if form.validate_on_submit():
user = User(username=form.username.data,
access_level=form.access_level.data)
user.set_password(form.password.data)
db.session.add(user)
db.session.commit()
flash("Nowy użytkownik zarejestrowany")
return redirect(url_for("acc.new_user"))
return render_template("acc_man/new_user.html",
title="Grafiki - nowy użytkownik",
form=form)
def select_guideline():
"""
Allows to select for which schedule guidelines will be created.
:return: template for choose year, month and workplace
"""
if acc_test.check_access(1) is False:
return redirect(url_for("main.index"))
title = "Grafiki - wytyczne"
form = SelectGuideline()
form.workplace.choices = select_guidelines_funcs.select_guidelines_choices(
)
if form.validate_on_submit():
return select_guidelines_funcs.select_guideline_validate(form)
return render_template("schedules/select-guideline.html",
title=title,
mn=MONTH_NAMES,
form=form)
def create_guideline():
"""
Template with calendar where user can input guidelines.
:return: template for guidelines
"""
if acc_test.check_access(1) is False:
return redirect(url_for("main.index"))
year = int(request.args.get("y"))
month = int(request.args.get("m"))
workplace = Shop.query.filter_by(shopname=request.args.get("w")).first()
return render_template("schedules/create-guideline.html",
year=year,
month=month,
workplace=workplace,
mn=MONTH_NAMES,
wdn=WEEKDAY_NAMES,
cal=Calendar(),
Guidelines=Guidelines)
def worker_to_workplace_workers(workplace):
"""
Makes list of workers unassigned to chosen workplace
:param workplace: chosen workplace
:return: list of workers
"""
if acc_test.check_access(0) is False:
return redirect(url_for("main.index"))
shop = Shop.query.filter_by(shopname=workplace).first()
workers_appended = shop.works.all()
workers_all = User.query.order_by(User.username).all()
workers = []
for worker in workers_all:
if worker not in workers_appended:
workers.append(worker)
jsondict = []
for worker in workers:
workers_list = {"name": worker.username}
jsondict.append(workers_list)
return jsonify({"workers": jsondict})
def accept_modify_schedule():
"""
:return: creates template with modifiable version of chosen unaccepted schedule and unmodifiable view.
"""
if acc_test.check_access(1) is False:
return redirect(url_for("main.index"))
action = request.args.get("action")
cal = Calendar()
to_render = accept_or_modify_schedule.acc_mod_schd(action)
prev = to_render["prev"]
return render_template("schedules/accept-schedule.html",
action=action,
title=to_render["title"],
workplace=to_render["workplace"],
year=to_render["year"],
month=to_render["month"],
workers=to_render["workers"],
month_name=to_render["month_name"],
wdn=WEEKDAY_NAMES,
Billing_period=Billing_period,
version=to_render["version"],
shdict=to_render["shdict"],
hours=to_render["hours"],
prev_shdict=prev["prev_shdict"],
prev_month=prev["month"],
prev_hours=prev["hours"],
prev_month_name=prev["month_name"],
prev_year=prev["year"],
prev_workers=prev["workers"],
workers_hours=prev["workers_hours"],
cal=cal,
id=to_render["schedule_id"],
Guidelines=Guidelines,
Shop=Shop)
def acc_mod_schd(action):
"""
:param action: modify schedule or accept modifications
:return: dictionary with data to render template in route
"""
title = "Grafiki"
schedule = None
if action == "to_accept":
if acc_test.check_access(1) is False:
return redirect(url_for("main.index"))
schedule = Schedule.query.filter_by(name=request.args.get("schd"),
version=int(request.args.get("v")),
accepted=False).first()
title = "Grafiki - akceptacja grafiku"
elif action == "to_modify":
if acc_test.check_access(2) is False:
return redirect(url_for("main.index"))
schedule = Schedule.query.filter_by(name=request.args.get("schd"),
version=int(request.args.get("v")),
accepted=True).first()
title = "Grafiki - modyfikacja grafiku"
if not schedule:
flash("Nie ma takiego grafiku")
return redirect(url_for("schedules.accept_modify_schedule"))
schedule_id = schedule.id
workplace = schedule.workplace
year = schedule.year
month = schedule.month
hours = schedule.hrs_to_work
version = schedule.version
workers = []
for pers_schedule in schedule.ind:
if str(pers_schedule.worker).replace(" ", "_") not in workers:
workers.append(str(pers_schedule.worker).replace(" ", "_"))
month_name = MONTH_NAMES[month - 1]
prev = prev_schedule.prev_schedule(month, year, workplace)
shdict = {}
for worker in workers:
for day in Calendar().itermonthdays(year, month):
if day > 0:
begin = Personal_schedule.query.filter_by(
date=datetime(year, month, day),
includes_id=schedule_id,
worker=worker.replace("_", " ")).first().begin_hour
end = Personal_schedule.query.filter_by(
date=datetime(year, month, day),
includes_id=schedule_id,
worker=worker.replace("_", " ")).first().end_hour
event = Personal_schedule.query.filter_by(
date=datetime(year, month, day),
includes_id=schedule_id,
worker=worker.replace("_", " ")).first().event
if begin == 0:
begin = ""
shdict["begin-%s-%d-%02d-%02d" %
(worker, year, month, day)] = begin
if end == 0:
end = ""
shdict["end-%s-%d-%02d-%02d" %
(worker, year, month, day)] = end
shdict["event-%s-%d-%02d-%02d" %
(worker, year, month, day)] = event
schedules = {
"prev": prev,
"shdict": shdict,
"schedule_id": schedule.id,
"workplace": workplace,
"year": year,
"month": month,
"month_name": month_name,
"workers": workers,
"hours": hours,
"version": version,
"title": title
}
return schedules