def add_edit_entry(entry_id=None):
if entry_id:
entry = models.Entry.get(models.Entry.id == entry_id)
form = forms.EditForm()
if form.validate_on_submit():
query = (models.Entry.update({
models.Entry.title:
form.title.data.strip(),
models.Entry.time_spent:
form.time_spent.data,
models.Entry.date:
form.date.data,
models.Entry.what_i_learned:
form.what_i_learned.data.strip(),
models.Entry.resources:
form.resources.data.strip()
}).where(models.Entry.id == entry_id))
query.execute()
return redirect(url_for('detail', entry_id=entry_id))
return render_template('edit.html', form=form, entry=entry)
else:
form = forms.EntryForm()
if form.validate_on_submit():
models.Entry.create(
title=form.title.data.strip(),
date=form.date.data,
time_spent=form.time_spent.data,
what_i_learned=form.what_i_learned.data.strip(),
resources=form.resources.data.strip())
return redirect(url_for('index'))
return render_template('new.html', form=form)
def entries_edit(id):
try:
journal_entry = models.Entry.get_by_id(id)
except models.DoesNotExist:
flash("Journal entry does not exist!", "error")
return redirect(url_for('index'))
else:
form = forms.EditForm(title=journal_entry.title,
date=journal_entry.date,
time=journal_entry.time,
learned=journal_entry.learned,
resources=journal_entry.resources)
if form.validate_on_submit():
models.Entry.update(user=g.user._get_current_object(),
title=form.title.data.strip(),
date=form.date.data,
time=form.time.data,
learned=form.learned.data.strip(),
resources=form.resources.data.strip()).where(
models.Entry.id == id).execute()
flash("Entry Updated!", "success")
return redirect('/entries/{}'.format(id))
else:
print('here now')
return render_template('edit.html', form=form, entry=journal_entry)
def edit(task_id):
if 'username' not in session:
return redirect('/')
try:
task_id = int(task_id)
except:
return render_template('error.html', message='Invalid task'), 400
user = db.get(session['username'])
task = next((task for task in user['tasks'] if task['id'] == task_id),
None)
if task is None:
return render_template('error.html', message='Task not found'), 404
if request.method == 'GET':
return render_template('edit.html', id=task['id'])
elif request.method == 'POST':
form = forms.EditForm(request.form)
if not form.validate():
return render_template('error.html', message='Invalid edit'), 400
for attribute in ['title', 'content', 'priority']:
if form[attribute].data:
task[attribute] = form[attribute].data
db.put(session['username'], user)
return redirect('/tasks')
def edit_book(bookid):
""" Edit book form view """
book = Item.query.get(bookid)
# pass existing image url for preview in form
img_url = Item.query.get(bookid).img_url
# pre-populate edit form
form = forms.EditForm(obj=book)
if request.method == 'POST':
if form.validate_on_submit():
# check for new image and update it in db
if request.files['image']:
img_filename = images.save(request.files['image'])
img_url = images.url(img_filename)
book.img_filename = img_filename
book.img_url = img_url
form.populate_obj(book)
db.session.commit()
return redirect(url_for('show_collection'))
else:
return render_template('edit_form.html',
form=form,
id=bookid,
img=img_url)
elif request.method == 'GET':
return render_template('edit_form.html',
form=form,
id=bookid,
img=img_url)
def edit_post(id):
"""Edit a journal entry"""
try:
post = models.Post.get_by_id(id)
except models.DoesNotExist:
abort(404)
else:
form = forms.EditForm(title=post.title,
date=post.date,
time_spent=post.time_spent,
what_i_learned=post.what_i_learned,
resources_to_remember=post.resources_to_remember)
if form.validate_on_submit():
post.title = form.title.data.strip()
post.date_created = form.date.data
post.time_spent = form.time_spent.data
post.what_i_learned = form.what_i_learned.data.strip()
post.resources_to_remember = form.resources_to_remember.data.strip(
)
post.save()
flash("Entry has been updated", "success")
models.PostTags.tag_new_post(
models.Post.get(title=form.title.data.strip()))
models.PostTags.remove_existing_tag(
models.Post.get(title=form.title.data.strip()))
return redirect(url_for('view_posts'))
return render_template('edit.html', form=form, post=post)
def edit_entry(id):
"""Edit a journal entry"""
try:
entry = models.Entry.get_by_id(id)
except models.DoesNotExist:
abort(404)
else:
form = forms.EditForm(title=entry.title,
time_spent=entry.time_spent,
date_created=entry.date_created,
content=entry.content,
resources=entry.resources)
if form.validate_on_submit():
entry.title = form.title.data.strip()
entry.time_spent = form.time_spent.data
entry.date_created = form.date_created.data
entry.content = form.content.data.strip()
entry.resources = form.resources.data.strip()
entry.save()
flash("Entry has been updated", "success")
models.EntryTags.tag_new_entry(
models.Entry.get(title=form.title.data.strip()))
models.EntryTags.remove_existing_tag(
models.Entry.get(title=form.title.data.strip()))
return redirect(url_for('view_entries'))
return render_template('edit.html', form=form, entry=entry)
def edit_entry(id):
try:
entry = models.Entry.get(models.Entry.id == id)
except models.DoesNotExist:
abort(404)
else:
form = forms.EditForm(title=entry.title,
date=entry.date,
time_spent=entry.time_spent,
learned=entry.learned,
resources=entry.resources)
if form.validate_on_submit():
entry.title = form.title.data.strip()
entry.date = form.date.data
entry.time_spent = form.time_spent.data
entry.learned = form.learned.data.strip()
entry.resources = form.resources.data.strip()
entry.save()
flash("Entry updated.", "success")
models.EntryTag.remove_tag(
models.Entry.get(title=form.title.data.strip()))
models.EntryTag.tag_new_entry(
models.Entry.get(title=form.title.data.strip()))
return redirect(url_for('index'))
return render_template('edit.html', form=form, entry=entry)
def edit_post(post_id):
form = forms.EditForm()
if form.validate_on_submit():
query = models.Post.update(content=form.content.data.strip()).where(
models.Post.id == post_id)
query.execute()
flash("Message Saved: Thanks!", "success")
user = current_user
return redirect(url_for('profile', username=user.username))
return render_template('edit_post.html', form=form)
def edit(entry_title):
'''Allows user to edit a journal entry'''
post = models.Entry.get(models.Entry.title == entry_title)
form = forms.EditForm(obj=post)
if form.validate_on_submit():
flash('Entry update successful!', 'success')
models.Entry.edit_entry(entry_title, form.title.data, form.date.data,
form.timespent.data, form.learned.data,
form.resources.data)
return redirect(url_for('list'))
else:
flash('Failed!')
print(form.errors)
return render_template('edit.html', form=form)
def edit_profile(id):
cur = mysql.connection.cursor()
cur.execute("SELECT * FROM users WHERE id = %s", (id))
user_edit = cur.fetchone()
cur.close()
form = forms.EditForm(request.form)
form.name.data = user_edit['name']
form.email.data = user_edit['email']
print(form.validate())
if request.method == 'POST' and form.validate():
print(request.method)
if request.form['password']:
password = sha256_crypt.encrypt(str(request.form['password']))
else:
password = user_edit['password']
name = request.form['name']
email = request.form['email']
print(name)
print(email)
print(password)
#Create cursor
cur = mysql.connection.cursor()
#Execute
if user_edit['name'] != name:
cur.execute("UPDATE users SET name = %s WHERE id = %s", (name, id))
flash('Tu nombre quedo editado', 'success')
if user_edit['email'] != email:
cur.execute("UPDATE users SET email = %s WHERE id = %s",
(email, id))
flash('Tu email quedo editado', 'success')
if user_edit['password'] != password:
cur.execute("UPDATE users SET password = %s WHERE id = %s",
(password, id))
flash('Tu password quedo editado', 'success')
# Commit to DB
mysql.connection.commit()
# Close connection
cur.close()
return redirect(url_for('my_notes'))
return render_template('edit_profile.html', form=form)
def edit(id):
"""Edit the entry."""
form = forms.EditForm()
entry = models.Entries.select().where(models.Entries.id == id)
if form.validate_on_submit():
try:
record = models.Entries.get(models.Entries.id == id)
record.title = form.title.data.strip()
record.slug = utils.slugcheck(form)
record.date = form.date.data
record.timeSpent = form.timeSpent.data
record.whatILearned = form.whatILearned.data
record.resourcesToRemember = form.ResourcesToRemember.data
record.save()
# process the tags
new_tags = utils.tagger(form.tags.data)
tags_in_db = {tag.tag for tag in models.Entries.tags(id)}
tags_to_delete = tags_in_db - new_tags
tags_to_add = new_tags - tags_in_db
# Remove unused tag references
for tag_to_delete in tags_to_delete:
tagref = (models.Tag.select()
.where(models.Tag.tag == tag_to_delete))
for tag in tagref:
tagrecord = (models.EntriesTagged
.get(models.EntriesTagged
.entry_ref == id and models
.EntriesTagged.tag_ref == tag.id))
tagrecord.delete_instance()
# Add any new tags
utils.add_tags(tags_to_add, id)
flash("Entry edited successfully!", "success")
return redirect(url_for('index'))
except models.IntegrityError:
flash("An error occured. Please try again.", "error")
for field, errors in form.errors.items():
for error in errors:
flash(error, "error")
return render_template('edit.html', form=form, entry=entry)
def edit_entries(entry_id):
"""
handles logic for updating both Entry and Tags
The entry_id is passed to the view through the URL
then the that id corresponding entry is queried: entry_to_edit
corresponding tags queried: entry_tags
entry_to_edit attr are processed before sending data to form
to ensure correct formatting of data. data is populated into
form1 ann form2 if form validates on submit
the form data is assigned to each attribute of entry_to_edit
then update query called upon the instance corresponding to
entry_to_edit and rows are updated new data.
if form2 is updated and validates on submit data is preprocessed
into list lists items are checked for duplication and membership:
classmethods create_or_get_tags is called if new tags are present
and classmethod Journaltags.create_relationship is called to instantiate
many to many relationship between entry_to_edit and tags. if tags are deleted
by user JournalTags.destroy_retionship classmethod is called severing relationship
between tags and entry
@var:form
@type:<forms.EditForm obj>
@var:tags
@type: list[str]
@var:parsed_tags
@type: str()
@param entry_id:
@type entry_id: int
@return: template render and response edit.html
@rtype: Union[str, None, werkzeug.wrappers.Response]
"""
# store value of query Entry with id that matches value passed
# queries
entry_to_edit = models.Entry.select().where(
models.Entry.id == entry_id).get()
entry_tags = (models.Tag.select().join(models.JournalTags).where(
models.JournalTags.entry == entry_to_edit).order_by(models.Tag.name))
# all_tags = models.Tag.select()
# variables
tags = [tag.name for tag in entry_tags]
parsed_tags = ','.join(tags)
entry_owner = entry_to_edit.user
entry_to_edit.date = datetime.strptime(entry_to_edit.date, '%Y-%m-%d')
entry_to_edit.resources = str.join('\n', entry_to_edit.resources)
entry_to_edit.time_spent = entry_to_edit.time_spent.hour * 60 + entry_to_edit.time_spent.minute
form = forms.EditForm(obj=entry_to_edit)
form1 = forms.TagForm(name=parsed_tags)
# constraints = if owner of the Entry is not the current user do not allow edit
if current_user == entry_owner:
# populate the entry form with data from select query
# upon the submit button update the contents of the entry
if form.validate_on_submit():
entry_to_edit.title = form.title.data
entry_to_edit.date = form.date.data
entry_to_edit.time_spent = timedelta(
minutes=float(form.time_spent.data))
entry_to_edit.knowledge = form.knowledge.data
entry_to_edit.resources = form.resources.data.splitlines()
models.Entry.save(entry_to_edit)
if form1.validate_on_submit():
# first convert form data into a list
tag_data = form1.name.data.split(',')
# iterate through unedited tags
for tag_obj in entry_tags:
# if the tag is not found in form data the relationship to the entry is broken
if tag_obj.name not in tag_data:
# break relations is a class method performs delete query at the through table
models.JournalTags.break_relations(tag_obj, entry_to_edit)
# iterate through the form tag list
for item in tag_data:
if item not in tags:
tag_data[:].remove(item)
tag = [models.Tag.get_or_create_tags(item)]
models.JournalTags.create_relations(entry_to_edit, tag)
# alert the user that the update has taken place
flash('hey we updated your entry', category='success')
return redirect(url_for('index'))
else:
flash('you need to be the entries owner to edit this',
category='error')
return redirect(url_for('index'))
return render_template('edit.html', form=form, form1=form1)
