def show_user(id):
"""User profile"""
if "user_id" not in session or id != session["user_id"]:
raise Unauthorized()
user = User.query.get(id)
form = DeleteForm()
return render_template("user.html", user=user, form=form)
def show_user(username):
if "username" not in session or username != session['username']:
raise Unauthorized()
user = User.query.get(username)
form = DeleteForm()
return render_template('show-user.html', user=user, form=form)
def show_user(username):
'''shows a page for logged in users'''
if 'username' not in session or username != session['username']:
raise Unauthorized()
user = User.query.filter_by(username=username).first()
form = DeleteForm()
return render_template('users/show.html', user=user, form=form)
def edit(id):
user_form = UserForm(obj=User.query.get_or_404(id))
delete_form = DeleteForm(obj=User.query.get_or_404(id))
return render_template('users/edit.html',
user=User.query.get_or_404(id),
user_form=user_form,
delete_form=delete_form)
def show_messages(id, message_id):
found_user = User.query.get_or_404(id)
found_message = Message.query.get_or_404(message_id)
if request.method == b'PATCH':
form = MessageForm(request.form)
if form.validate():
found_message.content = form.data['content']
db.session.add(found_message)
db.session.commit()
return redirect(
url_for('show_messages', id=id, message_id=message_id))
return render_template('messages/edit.html',
id=id,
message=found_message,
form=form)
if request.method == b'DELETE':
message_form = MessageForm(obj=request.form)
delete_form = DeleteForm(request.form)
if delete_form.validate():
db.session.delete(found_message)
db.session.commit()
return redirect(url_for('index_messages', id=id))
return render_template('messages/show.html',
user=found_user,
message=found_message)
def pow(val):
form = CommentForm()
deleteform = DeleteForm()
if form.validate_on_submit() and form.comment.data:
comment = models.Comment(comment=form.comment.data, userid=current_user.id, powid=val)
db.session.add(comment)
db.session.commit()
# elif deleteform.validate_on_submit():
# return redirect('/about')
comments = models.Comment.query.filter(models.Comment.powid == val).all()
pow = models.Prisoner.query.filter_by(id=val).first_or_404()
surname = pow.surname
capture = pow.Capture
firstnames = pow.first_names
if firstnames == None:
firstnames = pow.initial
count = models.Prisoner.query.filter(models.Prisoner.capture == capture.id).count()
# grammar for prisoner page
if isinstance(capture.date, str) == True:
inor = "on"
sent = "on this date"
else:
inor = "in"
sent = "at this location"
return render_template("prisoner.html", val=val, prisoner=pow, first_names=firstnames, inor=inor, sent=sent,
count=count, form=form, comments=comments)
def podcast_delete(podcast_id):
"""
Function that checks whether user is logged in. For logged in user it opens page with
more details of podcast to be deleted and short form to be submitted for a podcast
to be deleted. It searched database collection podcasts for the podcast using a
value "ObjectId(podcast_id)" of the key "_id".
For users that are not logged in it redirects to login page.
"""
if 'username' not in session:
flash(f'Oops... you need to be logged in to see this page.', 'danger')
return redirect(url_for('login'))
else:
delete_form = DeleteForm()
picked_podcast = mongo.db.podcasts.find_one(
{'_id': ObjectId(podcast_id)})
if delete_form.validate_on_submit():
existing_username = session['username']
existing_user = mongo.db.users.find_one(
{'username': existing_username})
if existing_user and check_password_hash(existing_user['password'],
delete_form.password.data):
mongo.db.podcasts.delete_one({'_id': ObjectId(podcast_id)})
flash(f'Podcast deleted', 'success')
return redirect(url_for('my_account'))
else:
flash(f'Oops, something went wrong. Please try again', 'danger')
return render_template('pages/podcast-delete.html',
form=delete_form,
podcast=picked_podcast,
title='Delete podcast')
def template(name=None):
t = db_session.query(TemplateModel).filter_by(name=name).first()
data = [
t.name, t.bash_script, t.image_dir, t.log_dir, t.mnt_option,
t.description
]
formu = TemplatesEditForm(mnt_option=t.mnt_option, prefix='formu')
if formu.validate_on_submit():
t.bash_script = formu.script.data
t.image_dir = formu.image.data
t.log_dir = formu.log_dir.data
t.mnt_option = formu.mnt_option.data
t.description = formu.desc.data
db_session.commit()
flash("template {} has been updated".format(name))
return redirect(url_for('templates'))
formd = DeleteForm(prefix='formd')
if formd.validate_on_submit():
db_session.delete(t)
db_session.commit()
flash("template {} has been deleted".format(name))
return redirect(url_for('templates'))
return render_template('template.html',
data=data,
formd=formd,
formu=formu)
def delete():
form = DeleteForm()
if form.validate_on_submit():
log = form.login.data #zapiseuvaem vvedeneui login v lo
pd = form.pswd.data #zapiseuvaem vvedeneui login v lo
def uidb(l, p): #user in db
#vozvrat true esli log+pd est' v bd i false v inom sluchae
connect('pick')
logvbd = models.User.objects.filter(login=l) #spisok iz 1 el
#proveryat' vvod na pustotu ne nado t.k. v formah est' validatory
if logvbd and g.user.login == l:
for s in logvbd: #s budet document (zapisiyu) s nuzhneum loginom
pdvbd = s.pswd #veutaskivaem parol etogo logina iz bd
if pdvbd == p: #parol na etot login sovpadaet s tem chto vvel user
s.delete()
return True
usdel = uidb(log, pd)
if usdel:
logout_user()
path = os.path.join('E:\\fss\\', log)
shutil.rmtree(path) #udalyaem papku i vse vlozhennoe
redirect(url_for("index"))
flash('Your account has been successfully deleted!')
else:
flash(
'Sorry, we do not have user with such login-password combination :('
)
return render_template('deleteacc.html', title='Delete account', form=form)
def deleteRecipe(cuisine_id, recipe_id):
"""Delete Cuisine page route"""
# Redirects to the login page if the user is not logged in
if 'username' not in login_session:
return redirect('/login')
# Fetches the recipe to delete it
cuisine = session.query(Cuisine).filter_by(id=cuisine_id).one()
recipeToDelete = session.query(Recipe).filter_by(cuisine_id=cuisine_id,
id=recipe_id).one()
# Checking authorization of the user
if recipeToDelete.user_id != login_session['user_id']:
return """<script>function myFunction() {
msg = 'You are not authorized to Delete this Recipe. ';
msg += 'Please create your own Recipe in order to Delete.';
alert(msg);window.location.replace('""" + (url_for(
'showRecipes', cuisine_id=cuisine.id)) + """');
}</script>
<body onload='myFunction()'>"""
# Creates the delete form
form = DeleteForm()
# POST method functionality
if request.method == 'POST':
# Checks if all the fields are valid
if form.validate_on_submit():
# Deletes the recipe and commits changes
session.delete(recipeToDelete)
flash('%s Successfully Deleted' % recipeToDelete.name)
session.commit()
return redirect(url_for('showRecipes', cuisine_id=cuisine_id))
return render_template('deleteRecipe.html',
recipe=recipeToDelete,
form=form,
cuisine=cuisine)
def new_feedback(username):
"""Show add-feedback form and process it."""
user = User.query.get_or_404(username)
if "username" not in session or username != session['username']:
flash('Not Authorized', "danger")
return redirect(f"/users/{session['username']}")
form = FeedbackForm()
if form.validate_on_submit():
title = form.title.data
content = form.content.data
feedback = Feedback(title=title, content=content, username=username)
db.session.add(feedback)
db.session.commit()
all_feedback = Feedback.query.all()
for feedback in all_feedback:
print(feedback.title)
form = DeleteForm()
return render_template('user_page.html', user=user, form=form)
else:
return render_template("add_feedback.html",
form=form,
username=username)
def completed(id):
page_index = request.args.get('page', 1, type=int)
query = Thing.query.filter_by(author_id=id).order_by(Thing.id.desc())
pagination = query.paginate(page_index, per_page=6, error_out=False)
post_index = pagination.items
thing_form = ThingForm()
if thing_form.validate_on_submit():
thing_add = Thing(thing=thing_form.thing.data,
author_id=id,
status_id=2)
db.session.add(thing_add)
db.session.commit()
return redirect(url_for('main.todo', id=id))
edit_form = EditForm()
delete_form = DeleteForm()
title = _('Things Completed')
return render_template(
'completed.html',
todolist=post_index,
thing_form=thing_form,
edit_form=edit_form,
delete_form=delete_form,
title=title,
pagination=pagination,
)
def delete_user():
form = DeleteForm()
status_code = 200
try:
email = current_user.email
except AttributeError:
return redirect('/login')
if form.validate_on_submit():
# verify user password
password = form.data['password']
delete_response = requests.delete(DATASERVICE + '/users/' +
str(current_user.id))
if delete_response.status_code == 204:
logout_user()
# delete the user and all his data
#_delete_user(user)
return redirect('/users')
else:
status_code = 401
return render_template('delete_user.html', form=form,
user_email=email), status_code
def delete():
user = current_user
form = DeleteForm()
if form.validate_on_submit():
db_session.delete(user)
db_session.commit()
if db_session.query(BlueScores).filter(BlueScores.username == user.username).scalar() != None:
blue = db_session.query(BlueScores).filter(BlueScores.username == user.username).first()
db_session.delete(blue)
db_session.commit()
flash('User deleted successfully!')
return redirect('/')
elif db_session.query(RedScores).filter(RedScores.username == user.username).scalar() != None:
red = db_session.query(RedScores).filter(RedScores.username == user.username).first()
db_session.delete(red)
db_session.commit()
flash('User deleted successfully!')
return redirect('/')
return render_template('delete_user.html', form=form)
def delete_user(username):
""" Delete the user by deleting all their posts first
Only allow this when the user is logged in
"""
if session.get('user_id') != username:
flash("You are not authorized to delete this user!")
return redirect("/")
user = User.query.get(username)
form = DeleteForm()
if form.validate_on_submit():
# Delete all the user's notes
Note.query.filter_by(owner=username).delete()
db.session.commit() # Not necessary
db.session.delete(user)
db.session.commit()
flash("User has been deleted")
# Clear any user info from the session
session.pop("user_id", None)
return redirect("/")
def delete():
form = DeleteForm(request.form)
if request.method == 'POST' and form.validate():
user = models.Users(id_num=form.del_id.data)
user.delete()
return redirect('/')
else:
return render_template('delete.html', form=form)
def delete(recipe_id):
# allows logged in user to delete a recipe that they've created
recipe_db = mongo.db.recipes.find_one_or_404({'_id': ObjectId(recipe_id)})
if request.method == 'GET':
form = DeleteForm(data=recipe_db)
return render_template('delete.html', title='Delete Drink', form=form)
form = DeleteForm(request.form)
if form.validate_on_submit():
recipes_db = mongo.db.recipes
recipes_db.delete_one({
'_id': ObjectId(recipe_id),
})
return redirect(url_for('home', title="Drink Deleted"))
return render_template('delete.html',
title="Delete Drink",
recipe=recipe_db,
form=form)
def edit_messages(id, message_id):
message_form = MessageForm(obj=Message.query.get_or_404(message_id))
delete_form = DeleteForm(obj=Message.query.get_or_404(message_id))
return render_template('messages/edit.html',
id=id,
message=Message.query.get_or_404(message_id),
message_form=message_form,
delete_form=delete_form)
def user_page(username):
if "username" not in session or username != session['username']:
return redirect('/login')
user = User.query.get_or_404(username)
form = DeleteForm()
return render_template('user.html', user=user, form=form)
def user_page(username):
if 'username' not in session:
flash(f"You're going to need to login first!", 'danger')
return redirect('/login')
user = User.query.get(username)
form = DeleteForm()
return render_template('user.html', user=user, form=form)
def delete_name():
delete_form = DeleteForm()
#If it does not validate, return home
if not delete_form.validate_on_submit():
return redirect(url_for('home'))
item_name = delete_form.name.data
delete_name_backpack(item_name)
return redirect(url_for('home'))
def delete_post(post_id):
post_db = mongo.db.posts.find_one({'_id': ObjectId(post_id)})
if request.method == 'GET':
form = DeleteForm(data=post_db)
return render_template('delete_post.html',
title="Delete post",
form=form)
form = DeleteForm(request.form)
if form.validate_on_submit():
posts_db = mongo.db.posts
posts_db.delete_one({
'_id': ObjectId(post_id),
})
flash("Review Deleted")
return redirect(url_for('get_posts', title='Review Deleted'))
return render_template('delete_post.html',
title="delete review",
form=form)
def delete_puppies(id):
current_puppies = Puppy.query.get_or_404(id)
form = DeleteForm()
if form.validate_on_submit():
db.session.delete(current_puppies)
db.session.commit()
flash('Your Puppies has been deleted!')
return redirect(url_for('list_puppies'))
return render_template('puppies/del_puppies.html', form=form, title='Delete')
def department_delete(did):
form = DeleteForm()
if form.validate_on_submit():
dept = Department.query.filter_by(did=did).first()
db.session.delete(dept)
db.session.commit()
flash('Department Deleted.')
return redirect(url_for('department_list_all'))
return render_template('/admin/dept_delete.html', form=form)
def employee_delete(id):
form = DeleteForm()
if form.validate_on_submit():
user = User.query.filter_by(id=id).one()
db.session.delete(user)
db.session.commit()
flash('User Deleted.')
return redirect(url_for('employee_list_all'))
return render_template('/admin/emp_delete.html',form=form)
def logout():
""" logs a user out and redirects to homepage"""
form = DeleteForm()
if form.validate_on_submit():
session.pop("username", None)
return redirect("/")
def show_user(username):
"""user detail page"""
if "username" not in session or username != session["username"]:
raise Unauthorized()
user = User.query.get(username)
form = DeleteForm()
return render_template('users/show.html', user=user, form=form)
def user_page(username):
"""Displays user info of logged-in-users."""
if "username" not in session or username != session['username']:
raise Unauthorized()
user = User.query.get(username)
form = DeleteForm()
return render_template("user.html", user=user, form=form)
def delete_witness():
form = DeleteForm(request.form)
if request.method == 'POST' and form.validate():
with db.session.begin(subtransactions=True):
id = form.id.data
person = Person.query.get(id)
db.session.delete(person)
db.session.commit()
return redirect(url_for('witness_list'))
return redirect(url_for('witness_list'))
def delete_member():
form = DeleteForm(request.form)
if request.method == 'POST' and form.validate():
with db.session.begin(subtransactions=True):
id = form.id.data
member = Member.query.get(id)
db.session.delete(member)
db.session.commit()
return redirect(url_for('member_list'))
return redirect(url_for('member_list'))
