def edit(entry_id):
form = forms.EntryForm()
if form.validate_on_submit():
models.Entry.update(title=form.title.data.strip(),
created_date=form.created_date.data,
time_spent=form.time_spent.data.strip(),
learned=form.learned.data.strip(),
resources=form.resources.data.strip()).where(
models.Entry.id == entry_id).execute()
models.Tag.delete().where(models.Tag.entry == entry_id).execute()
for tag in form.tags.data.strip().split('#')[1:]:
try:
models.Tag.create(entry=entry_id, tag_name=tag.strip())
except models.IntegrityError:
pass
return redirect(url_for('index'))
try:
entry = models.Entry.get_by_id(entry_id)
if entry.user != current_user:
raise PermissionError
tag_string = ''
for tag in entry.tags:
tag_string += '#' + tag.tag_name + ' '
entry.tags = tag_string.strip()
form = forms.EntryForm(obj=entry)
except models.DoesNotExist:
abort(404)
except PermissionError:
flash("You cannot edit another users entry", "error")
return redirect(url_for('index'))
else:
return render_template('edit.html', form=form, entry=entry)
def create_entry():
"""Creates a new entry."""
global last_route, cur_user, cur_entry, cur_tag
last_route = "create_entry"
cur_user = None
cur_entry = None
cur_tag = None
# Prompt to login, if the user isn't already.
if not current_user.is_authenticated:
return redirect(url_for("login"))
user = g.user._get_current_object() # noqa (accessing private method)
form = forms.EntryForm()
if form.validate_on_submit():
# All entries marked hidden are also private.
if form.hidden.data:
form.private.data = True
# Record creation.
entry = models.Entry.create(
user=user,
title=form.title.data,
date=form.date.data,
time_spent=form.time_spent.data,
learned=form.learned.data,
resources=form.resources.data,
tags=form.tags.data,
private=form.private.data,
hidden=form.hidden.data)
# Tags need to be added to the Tag and EntryTag tables. Searches for
# tags may be case-insensitive, but actual tags will be stored as-is.
update_tags(entry, entry.tags, "")
flash("Entry saved.", "success")
# Send the user back to their own page.
return redirect(url_for("user_entries", user=user.username))
return render_template(
"form.html", button="Create", form=form, cancel_url=url_for("index"))
def new_entry():
"""Entry Route"""
form = forms.EntryForm()
if form.validate_on_submit():
try:
models.Entry.create(
user=g.user._get_current_object(),
title=form.title.data.strip(),
date=form.date.data,
time_spent=form.time_spent.data.strip(),
what_i_learned=form.what_i_learned.data.strip(),
resources_to_remember=form.resources_to_remember.data.strip())
tags = form.tags.data.strip().split(" ")
for tag in tags:
models.Tag.create(entry=models.Entry.get(
models.Entry.title == form.title.data.strip()),
tag=tag)
except IntegrityError:
flash("Title must be unique.")
return render_template('new.html', form=form)
else:
flash("Journal entry created!")
return redirect(url_for('index'))
else:
return render_template('new.html', form=form)
def edit_entry(entry_id):
"""Modify an existing entry"""
try:
entry = models.Entry.get(models.Entry.id == entry_id)
form = forms.EntryForm(obj=entry)
except IndexError:
abort(404)
except ValueError:
abort(404)
else:
if form.validate_on_submit():
if 'update' in request.form:
entry.delete_instance()
edited_entry = models.Entry.create(
title=form.title.data,
date=form.date.data,
timespent=form.timespent.data,
learned=form.learned.data,
resources=form.resources.data)
flash('"{}" successfully modified!'.format(edited_entry.title))
return redirect(url_for('index'))
elif 'delete' in request.form:
entry.delete_instance()
flash('"{}" was removed u_u'.format(entry.title))
return redirect(url_for('delete_entry', title=entry.title))
return render_template('edit.html', entry_id=entry_id, form=form)
def create_entry():
form = forms.EntryForm()
if form.validate_on_submit():
slug_num = 1
while True:
try:
entry = models.Entry.create(
user=g.user.id,
title=form.title.data,
slug=sluged_title(form.title.data + '-' + str(slug_num)),
date=form.date.data,
time_spent=form.time_spent.data,
what_you_learned=form.what_you_learned.data,
resources_to_remember=form.resources_to_remember.data,
)
break
except IntegrityError:
slug_num += 1
for tag in tags_to_list(form.tags.data):
models.Tag.create(
tag=tag,
entry=entry
)
flash("Create new entry!", "success")
return redirect(url_for('index'))
form.date.data = datetime.datetime.now()
return render_template('new.html', form=form)
def edit(entry_id):
"""opens view to edit existing entry filling fields with existing entry for ease of use checks tags still exist"""
user = current_user
entry = models.Journal.get(models.Journal.entry_id == entry_id)
date = entry.date
if user.owner(entry):
form = forms.EntryForm(obj=entry)
if form.validate_on_submit():
list_tags = re.findall('#[a-zA-Z0-9\-_]+', form.tags.data)
new_tags = ""
for tag in list_tags:
new_tags += tag + " "
entry.user = g.user._get_current_object()
entry.title = form.title.data
entry.tags = new_tags
entry.date = form.date.data
entry.time_spent = form.time_spent.data
entry.learning = form.learning.data
entry.resources = form.resources.data
entry.save()
models.tags_persist(user)
models.add_tags(user, entry.tags)
flash("Journal Entry added! Thanks!")
return redirect(url_for("index"))
return render_template('edit.html', form=form, date=date)
else:
abort(404)
def index():
'''Get\'s users from the db and sorts by online status.
If the new entry form is passed it will try to create
an entry
'''
stream = models.Entry.select().order_by(-models.Entry.online)
form = forms.EntryForm()
if form.validate_on_submit():
if len(form.name.data.strip()) == 0:
models.Entry.create(ip=form.ip.data.strip(),
port=form.port.data.strip(),
online=True)
else:
models.Entry.create(name=form.name.data.strip(),
ip=form.ip.data.strip(),
port=form.port.data.strip(),
online=True)
flash('Entry created.', 'success')
else:
pass
return render_template('index.html', form=form, stream=stream)
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 edit_entry(entry_id):
"""
Allows user to edit a journal entry with the following fields: Title, Date,
Time Spent, What You Learned, Resources to Remember.
"""
try:
entry = models.Entry.select().where(models.Entry.id == entry_id).get()
except models.DoesNotExist:
abort(404)
else:
form = forms.EntryForm(obj=entry)
if request.method == 'POST':
if form.validate_on_submit():
if form.title.data != entry.title:
entry.slug = slugify(form.title.data)
entry.user = g.user._get_current_object()
entry.title = form.title.data
entry.date = form.date.data
entry.time_spent = form.time_spent.data
entry.learning = form.learning.data
entry.resources = form.resources.data
entry.tags = form.tags.data
entry.save()
flash("Journal entry has been updated!", "success")
return redirect(
url_for('details', entry_id=entry.id, slug=entry.slug))
return render_template("edit.html", form=form, entry=entry)
def edit_entry(entry_id):
try:
entry = models.Entry.get(entry_id)
except:
abort(404)
entry_dict = {
'content': entry.content,
'title': entry.title,
'timestamp': entry.timestamp,
'time_spent': entry.time_spent,
'resources': entry.resources
}
form = forms.EntryForm(data=entry_dict)
if form.validate_on_submit():
q = models.Entry.update(content=form.content.data.strip(),
title=form.title.data.strip(),
timestamp=form.timestamp.data,
time_spent=form.time_spent.data,
resources=form.resources.data.strip()).where(
models.Entry.id == entry_id)
q.execute()
flash("Entry Updated!", "success")
return redirect(url_for('index'))
return render_template('edit.html', entry=entry, form=form)
def edit(entry_id):
if not entry_id:
return redirect(url_for('entries'))
form = forms.EntryForm()
entry = models.Journal.get(models.Journal.id == entry_id)
try:
if entry.user.id != g.user.id:
flash("Modification not allowed if you are not the owner!",
"error")
return redirect(url_for('index'))
except:
flash("Modification not allowed if you are not the owner!", "error")
return redirect(url_for('index'))
# Add this line, this is what it gets pulled out of the database as:
print("resources:" + entry.resources)
# And then its data type
print(type(entry.resources))
if form.validate_on_submit():
entry.title = form.title.data
entry.entrydate = form.date.data
entry.timespent = form.timespent.data
entry.learned = form.learned.data
entry.resources = form.resources.data
entry.save()
return render_template('detail.html', entry=entry)
else:
form.title.data = entry.title
form.date.data = entry.entrydate
form.timespent.data = entry.timespent
form.learned.data = entry.learned
form.resources.data = entry.resources
return render_template('edit.html', form=form, entry=entry)
def new():
"""Define new entry view."""
form = forms.EntryForm()
if form.validate_on_submit():
slug = utils.slugcheck(form)
try:
entry = models.Entries.create(username=g.user.
_get_current_object(),
title=form.title.data.strip(),
slug=slug,
date=form.date.data,
timeSpent=form.timeSpent.data,
whatILearned=form.whatILearned.data,
resourcesToRemember=form.
ResourcesToRemember.data)
if form.tags.data: # add the tags (if entered)
tags = utils.tagger(form.tags.data)
utils.add_tags(tags, entry.id)
flash("Entry created successfully!", "success")
except models.IntegrityError:
flash("An error occured. Please try again.", "error")
return redirect(url_for('index'))
for field, errors in form.errors.items():
for error in errors:
flash(error, "error")
return render_template('new.html', form=form)
def add():
""" Add an entry to database """
# if the form is submitted
form = forms.EntryForm()
tag_form = forms.TagForm()
if form.validate_on_submit():
entry = models.Entry.create(title=form.title.data,
date=form.date.data,
duration=form.duration.data,
learned=form.learned.data,
resources=form.resources.data,
slug=slugify(form.title.data))
if tag_form.validate_on_submit():
tags = tag_form.tags.data
split_tags = [tag.strip() for tag in tags.split(',')]
for split_tag in split_tags:
if len(split_tag) > 0:
models.Tag.create(tag=split_tag,
entry=entry,
slug=slugify(split_tag))
# tell them the entry was created
flash('Entry created')
return redirect(url_for('index'))
# forward to the details page
return render_template('new.html', form=form, tag_form=tag_form)
def edit(entry_id):
"""This is where the user can edit an Entry."""
try:
entry = models.Entry.get(models.Entry.id == entry_id)
except IndexError:
abort(404)
except ValueError:
abort(404)
else:
# This gets the forms prefilled with the entry's data
form = forms.EntryForm(obj=entry)
if form.validate_on_submit():
models.Entry.create(user=g.user.id,
title=form.title.data,
entry_date=form.entry_date.data,
# submit_date is used here to keep the same
# order for sorting.
submit_date=entry.submit_date,
time_spent=form.time_spent.data,
learned=form.learned.data,
resources=form.resources.data
)
entry.delete_instance()
flash("Your Journal entry has been edited.", "success")
return redirect(url_for('index'))
else:
return render_template('edit.html', entry=entry, form=form)
def edit_entry(entry_id, slug):
entry = models.Entries.select().where(models.Entries.id == entry_id)
form = forms.EntryForm()
if form.validate_on_submit():
entry_id = request.form['entry_id']
update = models.Entries.update(
title=form.title.data,
date=form.date.data,
time_spent=form.time_spent.data,
learned=form.learned.data,
resources=form.resources.data,
tags=form.tags.data,
slug=slugify(form.title.data)).where(models.Entries.id == entry_id)
update.execute()
flash("Entry edited!", "success")
return redirect(url_for('index'))
for value in entry:
form.title.default = value.title
form.date.default = value.date
form.time_spent.default = value.time_spent
form.learned.default = value.learned
form.resources.default = value.resources
form.tags.default = value.tags
form.process()
return render_template('edit.html', entry=entry, form=form)
def edit_entry(entry_id):
"""Allows the user to edit an entry, if they are authorized to do so."""
global last_route, cur_user, cur_entry, cur_tag
last_route = "edit_entry"
cur_user = None
cur_entry = entry_id
cur_tag = None
# Prompt to login if the user isn't already.
if not current_user.is_authenticated:
return redirect(url_for("login"))
user = g.user._get_current_object() # noqa (accessing private method)
try:
# Entries can only be edited by the author (or god).
entry = models.Entry.get(models.Entry.id == entry_id)
if (user != entry.user and user.god == False): # noqa
raise models.DoesNotExist
except models.DoesNotExist:
# Display a non-specific error message. (If redirected from the login
# page, flush the login message.)
get_flashed_messages()
flash("Cannot edit entry.", "error")
return redirect(url_for("show_entry", entry_id=entry_id))
form = forms.EntryForm()
old_tags = ""
# Only pre-populate the fields before initial display.
if request.method == "GET":
# Get the current tag list to compare to any changes the user makes.
old_tags = entry.tags
form.title.data = entry.title
form.date.data = entry.date
form.time_spent.data = entry.time_spent
form.learned.data = entry.learned
form.resources.data = entry.resources
form.tags.data = entry.tags
form.private.data = entry.private
form.hidden.data = entry.hidden
# Process the submitted form.
if form.validate_on_submit():
entry.title = form.title.data
entry.date = form.date.data
entry.time_spent = form.time_spent.data
entry.learned = form.learned.data
entry.resources = form.resources.data
entry.tags = form.tags.data
entry.private = form.private.data
entry.hidden = form.hidden.data
# All entries that are hidden are also private.
#
# (Yes, I could use two radio buttons to implement this. I'm not.)
if form.hidden.data:
entry.private = True
entry.save()
# Update tags (add new tags, delete deleted tags).
update_tags(entry, entry.tags, old_tags)
flash("Entry edited.", "success")
return redirect(url_for("show_entry", entry_id=entry_id))
return render_template(
"form.html", button="Update", form=form, cancel_url=get_last_route())
def add():
"""add entry form"""
form = forms.EntryForm()
if form.validate_on_submit():
data = request.form.to_dict()
entry_list = models.convert_form_data(data)
models.add_entries(entry_list)
return redirect(url_for('index'))
return render_template('new.html', form=form)
def new():
form = forms.EntryForm()
if form.validate_on_submit():
models.Entry.create(title=form.title.data.strip(),
date=form.date.data,
timeSpent=form.timeSpent.data.strip(),
whatILearned=form.whatILearned.data,
ResourcesToRemember=form.ResourcesToRemember.data)
flash('Your entry has been Recorded, Good Job Today!', 'success')
return redirect(url_for('index'))
return render_template('new.html', form=form)
def delete_entry(slug):
"""View for user to delete entry"""
if slug:
entry = models.Entry.select().where(models.Entry.slug == slug).get()
form = forms.EntryForm(obj=entry)
if form.validate_on_submit():
models.Entry.delete().where(models.Entry.slug == slug).execute()
flash('Entry deleted !', 'success')
return redirect(url_for('index'))
return render_template('delete.html', form=form)
def add_entry():
form = forms.EntryForm()
if form.validate_on_submit():
models.Entry.create(title=form.title.data,
timespent=form.timespent.data,
stuff_learned=form.stuff_learned.data.strip(),
resources_to_remember=form.resources_to_remember.
data.strip()).save()
flash("Entry Saved!", "Success!")
return redirect(url_for('index'))
return render_template('new.html', form=form)
def entries_new():
form = forms.EntryForm()
if form.validate_on_submit():
models.Entry.create(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())
flash("Entry Posted!", "success")
return redirect(url_for('index'))
return render_template('new.html', form=form)
def new_entry():
form = forms.EntryForm()
if form.validate_on_submit():
#validate_on_submit check if it's a POST request and if it's valid
entry = models.Entry.create_entry(title=form.title.data,
date=form.date.data,
timespent=form.timespent.data,
learned=form.learned.data,
resources=form.resources.data)
flash('Task successfully registered!')
return redirect(url_for('index', entry_id=entry))
return render_template('new.html', form=form)
def create():
"""Creates a new Entry."""
form = forms.EntryForm()
if form.validate_on_submit():
models.Entry.create(title=form.title.data.strip(),
created=form.create.data,
time_spent=form.timespent.data,
learned=form.learned.data.strip(),
to_remember=form.to_remember.data.strip())
flash("This entry has been created!", "success")
return redirect(url_for('index'))
return render_template('new.html', form=form)
def newentry():
form = forms.EntryForm()
if form.validate_on_submit():
models.Journal.create_entry(title=form.title.data,
entrydate=form.date.data,
user=g.user.id,
timespent=form.timespent.data,
learned=form.learned.data,
resources=form.resources.data.replace(
'\r', ''))
return redirect(url_for('index'))
return render_template('new.html', form=form)
def new_entry():
form = forms.EntryForm()
if form.validate_on_submit():
print('validated')
models.Entry.create(content=form.content.data.strip(),
title=form.title.data.strip(),
timestamp=form.timestamp.data,
time_spent=form.time_spent.data,
resources=form.resources.data.strip())
flash("Entry Saved", "success")
return redirect(url_for('index'))
return render_template('new.html', form=form)
def new_entry():
""" Allows user to add an entry """
form = forms.EntryForm()
if form.validate_on_submit():
models.Entry.create(title=form.title.data.strip(),
date=form.date.data,
duration=form.duration.data,
learned=form.learned.data.strip(),
resources=form.resources.data.strip())
flash('Entry added!', 'success')
return redirect(url_for('index'))
return render_template('new.html', form=form)
def add_entry():
"""Route for adding a new entry to the blog"""
form = forms.EntryForm()
if form.validate_on_submit():
models.Entry.create(title=form.title.data,
date=form.date.data,
spent=form.spent.data,
learned=form.learned.data,
resources=form.resources.data)
flash("Success! New journal entry created.", "success")
return redirect(url_for('index'))
return render_template('new.html', form=form)
def new_entry():
""" Add new entry """
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,
learned=form.learned.data.strip(),
resources=form.resources.data.strip())
flash('New entry added!!', 'success')
return redirect(url_for('entries'))
return render_template('new.html', form=form)
def new_entry():
"""New Entry"""
form = forms.EntryForm()
if form.validate_on_submit():
models.Entry.create_entry(
title=form.title.data.strip(),
date=form.date.data.strftime('%B %d, %Y'),
time_spent=form.time_spent.data.strip(),
what_you_learned=form.what_you_learned.data.strip(),
resources_to_remember=form.resources_to_remember.data.strip(),
tags=form.tags.data.strip())
return redirect(url_for('index'))
return render_template('new.html', form=form)
def new_entry():
form = forms.EntryForm()
if form.validate_on_submit():
models.Entry.create(
title=form.title.data,
date=form.date.data,
time=form.time.data,
i_learned=form.i_learned.data,
resources=form.resources.data
)
flash("Saved and Published Entry", "success")
return redirect(url_for("index"))
return render_template("new.html", entry=form)
