def parse_entry(self, e, session=None):
if session is None:
session = db.session.object_session(e)
if session is None:
session = db.session()
session.add(e)
seen = set()
words = list(w for w in pattern.findall(e.contents)
if w.lower() not in all_stopwords)
out = []
for w in words:
try:
if w[0] == w[0].upper():
if w not in seen:
c = count_occurrences(
webapp.models.User.query.filter(
webapp.models.User.id == e.owner_id).first(),
w)
label = f'{w}'
url = flask.url_for(
f'site.plugins-{self.safe_name}-index',
page=1,
search=w)
out.append(
dict(
html=f'<a href="{url}" >{label}</a>',
url=url,
label=label,
))
seen.add(w)
except IndexError:
pass
yield from out
def get_objects(self, **kwargs):
start_date = self.args_to_date(**kwargs)
session = kwargs.get('session', db.session())
found = list(flask_login.current_user.query_all_entries().filter(
models.JournalEntry.create_date >= start_date).order_by(
models.JournalEntry.create_date))
return found
def parse_entry(self, e, session=None):
if session is None:
session = db.session.object_session(e)
if session is None:
session = db.session()
session.add(e)
out = []
for h in extract_headings(e):
item = dict(html=h, label=h)
yield item
def get_preference_model(self, user_obj):
obj = db.session.query(models.UserPluginToggle).filter(
models.UserPluginToggle.user_id == user_obj.id).filter(
models.UserPluginToggle.plugin_name == self.name).first()
if obj is None:
session = db.session()
obj = models.UserPluginToggle(plugin_name=self.name,
user_id=user_obj.id)
session.add(obj)
session.commit()
return models.user_plugin_toggle_schema.dump(obj=obj)
def post(self, **kwargs):
session = db.session()
cu = flask_login.current_user
obj = models.JournalEntry.query.filter_by(id=kwargs['id']).first()
if not obj:
flask.abort(404)
if cu == obj.owner:
old_date = obj.date_string
session.delete(obj)
session.commit()
return flask.redirect(
flask.url_for('home', success=f'Deleted entry for {old_date}'))
def post(self):
cu = flask_login.current_user
form = forms.UserEditForm(obj=cu)
if form.validate_on_submit():
session = db.session()
cu.first_name = form.first_name.data
cu.last_name = form.last_name.data
cu.email = form.email.data
session.add(cu)
session.commit()
# cu.update_settings(form)
else:
return flask.render_template(context=dict(settings_form=form))
return flask.redirect(flask.url_for('settings'))
def post(self, **kwargs):
upload_form = forms.UploadForm()
self.logger.debug('Try upload')
good_parse = False
if upload_form.validate_on_submit():
logger.debug('Invalid form')
file = flask.request.files[upload_form.file.name]
session = db.session()
try:
parsed = parsing.identify_entries(
file.read().decode().split('\n'))
except ValueError as e:
# upload_form.file.errors
self.logger.debug('parse failed')
return self.get(upload_form=upload_form, error=e)
flask_login.current_user.query_all_entries().delete()
for e in parsed:
body_text = e.body.replace('\r', '')
found = flask_login.current_user.query_all_entries().filter_by(
create_date=e.date).first()
if found:
found.contents = body_text
else:
found = models.JournalEntry(owner=flask_login.current_user,
create_date=e.date,
contents=body_text)
plugin_manager.parse_entry(found)
session.add(found)
session.flush()
session.commit()
self.logger.debug('parse succeeded')
good_parse = True
if good_parse:
# pre-calculate any plugins that happen to cache things.
db.session.add(flask_login.current_user)
q = list(flask_login.current_user.query_all_entries())
for e in q:
db.session.add(e)
list(plugin_manager.parse_entry(e))
return self.get(upload_form=upload_form,
success='Your journal was successfully parsed!')
else:
return self.get(upload_form=upload_form,
error='Invalid submission!')
def _parse_entry_cached(self,
e: 'webapp.models.JournalEntry') -> 'List[str]':
if not self.__class__.__cache_enabled__:
results = list(self.parse_entry(e))
return results
session = db.session
session.add(e)
found = session.query(models.PluginOutputCache).filter(
models.PluginOutputCache.parent_id == e.id).filter(
models.PluginOutputCache.plugin_name ==
self.safe_name).first()
if found:
if (found.updated_at < e.updated_at or found.schema_version is None
or found.schema_version <
self.__class__.cache_schema_version):
results = list(self.parse_entry(e))
found.json = json.dumps(results)
session.add(found)
session.commit()
else:
results = json.loads(found.json)
try:
if len(results) == 0:
results = list(self.parse_entry(e))
return PluginReturnValue(results).dict
except ValueError:
session.delete(found)
session.commit()
results = list(self.parse_entry(e))
found = models.PluginOutputCache(
parent=e,
json=json.dumps(results),
plugin_name=self.safe_name,
schema_version=self.__class__.cache_schema_version)
session = db.session.object_session(e)
if session is None:
session = db.session()
session.add(found)
session.commit()
return results
def post(self, **kwargs):
form = forms.JournalEntryEditForm(**flask.request.form)
cu = flask_login.current_user
context = dict(errors=list())
if form.validate_on_submit():
if form.owner_id.data == cu.id:
obj = models.JournalEntry.query.filter_by(id=form.id.data,
owner=cu).first()
form.populate_obj(obj)
session = db.session()
session.add(obj)
session.commit()
return flask.redirect(api.link_for_entry(obj))
else:
flask.abort(403)
else:
context['errors'].append('form invalid')
return self.get(**context)
def post(self, **kwargs):
form = forms.JournalEntryCreateForm(**flask.request.form)
context = dict(form=form, errors=[])
context.update(**kwargs)
if form.validate_on_submit():
obj = models.JournalEntry(owner=flask_login.current_user)
form.populate_obj(obj)
print('obj', obj.owner)
session = db.session()
try:
session.add(obj)
session.commit()
except sqlalchemy.exc.IntegrityError:
session.rollback()
context['errors'].append('That date already has an entry!')
return self.get(**context)
return flask.redirect(
api.link_for_entry(
flask_login.current_user.get_latest_entry()))
else:
return self.get(**context)
