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)