def papers_delete(paperID):
""" Delete Paper """
connection = engine.connect()
transaction = connection.begin()
return_status = paper.delete(connection, paperID)
transaction.commit()
return return_status
def filmstock():
""" Filmstock Index """
connection = engine.connect()
transaction = connection.begin()
userID = current_user.get_id()
form = FilmStockForm(connection)
if request.method == 'POST':
if request.form.get('button') == 'add':
qty = request.form.get('qty')
if request.form.get('filmTypeID') != '':
if qty != '':
qty = int(qty)
qry = text("""REPLACE INTO FilmStock
(filmTypeID, filmSizeID, userID, qty)
VALUES (:filmTypeID, :filmSizeID, :userID, :qty)""")
connection.execute(qry,
filmTypeID=form.filmTypeID.data,
filmSizeID=form.filmSizeID.data,
qty=form.qty.data,
userID=userID)
qry = text("""SELECT FilmTypes.filmTypeID AS filmTypeID,
FilmTypes.name AS type, iso
FROM FilmTypes
WHERE userID = :userID""")
films = connection.execute(qry, userID=userID).fetchall()
transaction.commit()
return render_template('films/stock.html', form=form, films=films)
def user_holders():
""" Manage holders """
connection = engine.connect()
transaction = connection.begin()
userID = current_user.get_id()
form = HolderForm()
if request.method == 'POST':
if request.form['button'] == 'addHolder':
nextHolderID = next_id(connection, 'holderID', 'Holders')
qry = text("""INSERT INTO Holders
(userID, holderID, name, size, notes)
VALUES (:userID, :holderID, :name, :size, :notes)""")
connection.execute(qry,
userID=userID,
holderID=nextHolderID,
name=form.name.data,
size=form.size.data,
notes=form.notes.data)
form.populate_select_fields(connection)
transaction.commit()
if request.args.get('print'):
template = '/gear/holders-print.html'
else:
template = '/gear/holders.html'
return render_template(template, form=form)
def user_lens(lensID):
""" Manage a specific lens """
connection = engine.connect()
transaction = connection.begin()
userID = current_user.get_id()
shutter_speed_form = LensShutterSpeedsForm()
if request.method == 'POST':
if request.form['button'] == 'addSpeed':
if shutter_speed_form.validate_on_submit():
qry = text("""REPLACE INTO LensShutterSpeeds
(userID, lensID, speed, measuredSpeedMicroseconds)
VALUES (:userID, :lensID, :speed, :measuredSpeedMicroseconds)"""
)
# pylint: disable=line-too-long
# Haven't found a great way to format this without it being
# more ugly.
connection.execute(
qry,
speed=shutter_speed_form.speed.data,
measuredSpeedMicroseconds=shutter_speed_form.
measuredSpeedMicroseconds.data,
userID=userID,
lensID=lensID)
if request.form['button'] == 'deleteSpeed':
qry = text("""DELETE FROM LensShutterSpeeds
WHERE userID = :userID
AND lensID = :lensID
AND speed = :speed""")
connection.execute(qry,
userID=userID,
lensID=lensID,
speed=shutter_speed_form.speed.data)
qry = text("""SELECT lensID, name, shutter
FROM Lenses
WHERE userID = :userID
AND lensID = :lensID""")
lens = connection.execute(qry, userID=userID, lensID=lensID).fetchone()
qry = text("""SELECT speed, measuredSpeed,
idealSpeedMicroseconds, measuredSpeedMicroseconds,
differenceStops
FROM LensShutterSpeeds
WHERE userID = :userID
AND lensID = :lensID""")
shutter_speeds = connection.execute(qry, userID=userID,
lensID=lensID).fetchall()
transaction.commit()
if request.args.get('print'):
template = '/gear/lens-print.html'
else:
template = '/gear/lens.html'
return render_template(template,
lens=lens,
shutter_speeds=shutter_speeds,
shutter_speed_form=shutter_speed_form)
def load_camera(cameraID, filmTypeID):
""" Get camera """
connection = engine.connect()
transaction = connection.begin()
if request.method == 'PATCH':
return_status = cameras.loadFilm(connection, cameraID, filmTypeID)
transaction.commit()
return return_status
def all_film_test_graphs():
""" Get all user's curves of film """
connection = engine.connect()
transaction = connection.begin()
if request.method == 'GET':
return_status = filmtests.get_all_test_curves(connection)
transaction.commit()
return return_status
def enlargers_lenses():
""" Get enlargers information """
connection = engine.connect()
transaction = connection.begin()
if request.method == 'GET':
return_status = enlargers.get_all_lenses(connection)
transaction.commit()
return return_status
def search_index():
""" Index page for search section """
connection = engine.connect()
transaction = connection.begin()
userID = current_user.get_id()
search = re.escape(request.args.get('search'))
qry = text("""SELECT Projects.binderID, Projects.projectID,
Projects.name AS project_name, Binders.name AS binder_name,
filmCount, Projects.createdOn
FROM Projects
JOIN Binders ON Binders.binderID = Projects.binderID
AND Binders.userID = Projects.userID
WHERE Projects.userID = :userID
AND Projects.name LIKE ('%""" + search + """%')
ORDER BY createdOn""")
projects = connection.execute(qry, userID=userID, search=search).fetchall()
qry = text("""SELECT filmID, Films.projectID, binderID,
title, fileNo, fileDate,
Films.iso AS iso, FilmTypes.name AS filmName,
FilmSizes.size AS size, exposures,
Cameras.name AS camera
FROM Films
JOIN Projects ON Projects.projectID = Films.projectID
AND Projects.userID = Films.userID
LEFT OUTER JOIN FilmTypes ON FilmTypes.filmTypeID = Films.filmTypeID
AND FilmTypes.userID = Films.userID
JOIN FilmSizes ON FilmSizes.filmSizeID = Films.filmSizeID
JOIN Cameras ON Cameras.cameraID = Films.cameraID
AND Cameras.userID = Films.userID
WHERE Films.userID = :userID
AND (Films.title LIKE ('%""" + search + """%')
OR Films.notes LIKE ('%""" + search + """%'))
ORDER BY fileDate""")
films = connection.execute(qry, userID=userID).fetchall()
qry = text("""SELECT Films.title AS film_title, Exposures.filmID,
Films.projectID, Projects.binderID,
exposureNumber, shutter, aperture,
Exposures.subject, Exposures.notes
FROM Exposures
JOIN Films ON Films.filmID = Exposures.filmID
JOIN Projects ON Projects.projectID = Films.projectID
AND Projects.userID = Films.userID
WHERE Exposures.userID = :userID
AND (Exposures.subject LIKE ('%""" + search + """%')
OR Exposures.notes LIKE ('%""" + search + """%'))
ORDER BY Films.filmID, exposureNumber""")
exposures = connection.execute(qry, userID=userID).fetchall()
transaction.commit()
return render_template('search.html',
search=search,
projects=projects,
films=films,
exposures=exposures)
def cameras_active():
""" Get cameras information """
connection = engine.connect()
transaction = connection.begin()
if request.method == 'GET':
return_status = cameras.get_all(connection)
transaction.commit()
return return_status
def filmstock_all():
""" Get available filmstocks """
connection = engine.connect()
transaction = connection.begin()
if request.method == 'GET':
return_status = filmstock.get_all(connection)
transaction.commit()
return return_status
def holders_all_status(status):
""" Get all user's holders filmstock information """
connection = engine.connect()
transaction = connection.begin()
if request.method == 'GET':
return_status = holders.get_all(connection, status)
transaction.commit()
return return_status
def all_film_test_curves(filmTypeID):
""" Get all test curves of film """
connection = engine.connect()
transaction = connection.begin()
if request.method == 'GET':
return_status = filmtests.get_test_curves_from_film(
connection, filmTypeID)
transaction.commit()
return return_status
def film_sizes():
""" Get global film size information """
connection = engine.connect()
transaction = connection.begin()
if request.method == 'GET':
return_status = films.get_film_sizes(connection)
transaction.commit()
return return_status
def film_tests(filmTypeID):
""" Get user's film tests for specific film """
connection = engine.connect()
transaction = connection.begin()
if request.method == 'GET':
return_status = filmtests.get_tests(connection, filmTypeID)
if request.method == 'POST':
return_status = filmtests.add_test(connection, filmTypeID)
transaction.commit()
return return_status
def films_all(binderID, projectID):
""" Get details of a project """
connection = engine.connect()
transaction = connection.begin()
if request.method == 'GET':
return_status = films.get_all(connection, binderID, projectID)
if request.method == 'POST':
return_status = films.post(connection, projectID)
transaction.commit()
return return_status
def film_type_details(filmTypeID):
""" Get film type details """
connection = engine.connect()
transaction = connection.begin()
if request.method == 'GET':
return_status = films.get_film_type(connection, filmTypeID)
if request.method == 'DELETE':
return_status = films.delete_film_type(connection, filmTypeID)
transaction.commit()
return return_status
def step_tablets():
""" Get all user's step tablets and add new ones"""
connection = engine.connect()
transaction = connection.begin()
if request.method == 'GET':
return_status = steptablets.get_step_tablets(connection)
if request.method == 'POST':
return_status = steptablets.add_step_tablet(connection)
transaction.commit()
return return_status
def binders_all():
""" Get all binders """
connection = engine.connect()
transaction = connection.begin()
if request.method == 'GET':
return_status = binders.get_all(connection)
elif request.method == 'POST':
return_status = binders.post(connection)
transaction.commit()
return return_status
def user_preferences():
""" Get user's preferences """
connection = engine.connect()
transaction = connection.begin()
if request.method == 'GET':
return_status = user.get_preferences(connection)
if request.method == 'PATCH':
return_status = user.patch_preferences(connection)
transaction.commit()
return return_status
def camera(cameraID):
""" Get camera """
connection = engine.connect()
transaction = connection.begin()
if request.method == 'GET':
return_status = cameras.get(connection, cameraID)
if request.method == 'PATCH':
return_status = cameras.patch(connection, cameraID)
transaction.commit()
return return_status
def papers_all():
""" Get User's Papers """
connection = engine.connect()
transaction = connection.begin()
if request.method == 'GET':
return_status = paper.get_all(connection)
if request.method == 'POST':
return_status = paper.post(connection)
transaction.commit()
return return_status
def film_details(binderID, projectID, filmID):
""" Get details of a film """
connection = engine.connect()
transaction = connection.begin()
if request.method == 'GET':
return_status = films.get(connection, binderID, projectID, filmID)
if request.method == 'DELETE':
return_status = films.delete(connection, filmID)
transaction.commit()
return return_status
def holder_details(holderID):
""" Get detailed holder information """
connection = engine.connect()
transaction = connection.begin()
#if request.method == 'GET':
# return_status = filmstock.get(connection, filmTypeID, filmSizeID)
if request.method == 'PATCH':
return_status = holders.patch(connection, holderID)
transaction.commit()
return return_status
def projects_all(binderID):
""" Get all projects under a binder """
connection = engine.connect()
transaction = connection.begin()
if request.method == 'GET':
return_status = projects.get_all(connection, binderID)
elif request.method == 'POST':
return_status = projects.post(connection, binderID)
transaction.commit()
return return_status
def film_test(filmTypeID, filmTestID):
""" Get user's film test for specific film """
connection = engine.connect()
transaction = connection.begin()
if request.method == 'GET':
return_status = filmtests.get_test(connection, filmTypeID, filmTestID)
if request.method == 'DELETE':
return_status = filmtests.delete_test(connection, filmTypeID,
filmTestID)
transaction.commit()
return return_status
def step_tablet(stepTabletID):
""" Specifc step tablet interactions """
connection = engine.connect()
transaction = connection.begin()
if request.method == 'GET':
return_status = steptablets.get_step_tablet(connection, stepTabletID)
if request.method == 'DELETE':
return_status = steptablets.delete_step_tablet(connection,
stepTabletID)
transaction.commit()
return return_status
def films_list():
""" Get user's film types """
connection = engine.connect()
transaction = connection.begin()
if request.method == 'GET':
return_status = films.get_film_types(connection)
elif request.method == 'POST':
return_status = films.add_film_type(connection)
transaction.commit()
return return_status
def binder_details(binderID):
""" Get binder details """
connection = engine.connect()
transaction = connection.begin()
if request.method == 'GET':
return_status = binders.get(connection, binderID)
elif request.method == 'PATCH':
return_status = binders.patch(connection, binderID)
elif request.method == 'DELETE':
return_status = binders.delete(connection, binderID)
transaction.commit()
return return_status
def film_test_results(filmTypeID, filmTestID):
""" Get user's film test for specific film """
connection = engine.connect()
transaction = connection.begin()
if request.method == 'GET':
return_status = filmtests.get_test_results(connection, filmTypeID,
filmTestID)
if request.method == 'PATCH':
return_status = filmtests.update_test_results(connection, filmTypeID,
filmTestID)
transaction.commit()
return return_status
def filmstock_details(filmTypeID, filmSizeID):
""" Get detailed filmstock information """
connection = engine.connect()
transaction = connection.begin()
if request.method == 'GET':
return_status = filmstock.get(connection, filmTypeID, filmSizeID)
if request.method == 'PATCH':
return_status = filmstock.patch(connection, filmTypeID, filmSizeID)
if request.method == 'DELETE':
return_status = filmstock.delete(connection, filmTypeID, filmSizeID)
transaction.commit()
return return_status
