def _CleanEntryBase(feed_entity, entry_feedparser, content, original_content):
try:
updated = datetime.datetime(*entry_feedparser.updated_parsed[:6])
except AttributeError:
updated = datetime.datetime.now()
try:
tags = [c['term'] for c in entry_feedparser.tags]
except (AttributeError, KeyError):
tags = []
try:
title = entry_feedparser.title.replace('\n', '').replace('\r', '')
except AttributeError:
title = 'Unknown'
try:
link = entry_feedparser.link
except AttributeError:
link = 'Unknown'
entry_entity = models.Entry(key_name=_EntryId(entry_feedparser),
feed=feed_entity,
title=title,
link=link,
updated=updated,
content=content,
original_content=original_content,
tags=tags)
entry_entity.put()
def create_entry(feed, parsed_data):
"Creates a models.Entry object from the given parsed data and links it to the given models.Feed object"
logger.debug("creating entry")
entry = models.Entry(**parsed_data)
entry.feed = feed
entry.save()
return entry
def create():
topics = models.Topic.query.all()
tags = models.Tag.query.all()
return _create_or_edit(models.Entry(title='', content=''),
'create.html',
topics=topics,
tags=tags)
def add_entry():
try:
entry = models.Entry(request.form['address'], request.form['ssn'])
except:
raise
REGISTRY.append(entry)
flash('New entry was successfully posted')
return redirect(flask.url_for('show_entries'))
def add_entry():
if not session.get('logged_in'):
abort(401)
entry = models.Entry(request.form['title'], request.form['text'])
db_session.add(entry)
db_session.commit()
print db_session.session_factory
flash('New entry was succesfully posted')
return redirect(url_for('show_entries'))
def add_article():
form = forms.Add_Atricle()
if form.validate_on_submit():
atricle = models.Entry(title=form.title.data,
description=form.description.data,
content=form.content.data)
db.session.add(atricle)
db.session.commit()
return redirect(url_for('index'))
return render_template('add_article.html', form=form)
def _new_entry(self, parsed):
return models.Entry(
content=parsed.content[0].value,
id=parsed.id,
title=parsed.title,
summary=self._summary_as_plaintext(parsed.summary),
tags=[x.term for x in parsed.tags],
# 9-valued tuple: ( year, month, day, hour, minute, second, day of week, day of year, dst-flag )
# (Ref: http://stackoverflow.com/questions/686717/python-convert-9-tuple-utc-date-to-mysql-datetime-format)
published_at=datetime.datetime(*(parsed.published_parsed[:6])))
def create_entry(entry: schemas.EntryCreate, db: Session):
new_entry = models.Entry(entry_type=entry.entry_type,
duration=entry.duration,
wee=entry.wee,
poo=entry.poo,
full=entry.full,
notes=entry.notes)
db.add(new_entry)
db.commit()
db.refresh(new_entry)
return new_entry
def post(self):
post_values = self.request.POST
posted_date = datetime.datetime.strptime(post_values["date"],
"%Y-%m-%d")
posted_units = float(post_values["units"])
entry = models.Entry(date=posted_date, units=posted_units)
entry.put()
# delay to hack eventual consistency of ndb
time.sleep(1)
self.redirect('/')
def edit_entry(slug=None):
if slug:
entry = models.Entry.get(models.Entry.title == string.capwords(slug))
tag_query = (models.Tag
.select()
.join(models.TagList)
.join(models.Entry)
.where(models.Entry.title == entry.title))
title = 'Edit Entry'
else:
entry = models.Entry()
tag_query = []
title = 'Add Entry'
form = forms.EntryForm(obj=entry)
tags = ", ".join([tag.name.title() for tag in tag_query])
if form.validate_on_submit():
form.populate_obj(entry)
entry.title = string.capwords(form.title.data)
entry.date_created = form.date_created.data
entry.time_spent = form.time_spent.data
entry.learned = form.learned.data
entry.resources = form.resources.data
entry.save()
# Delete all tag lists already associated with model so data can overwrite
tag_list_query = (models.TagList
.select()
.join(models.Entry)
.where(models.Entry.title == entry.title))
for ls in tag_list_query:
ls.delete_instance()
# Create new tags if needed
for tag in re.split(r'[\s,]+', form.tags.data):
tag_name = tag.replace(",", "").title()
try:
new_tag = models.Tag.get(models.Tag.name == tag_name)
except models.DoesNotExist:
new_tag = models.Tag.create(name=tag_name)
models.TagList.create(tag=new_tag, entry=entry)
return redirect(url_for('view_entry', slug=entry.title))
return render_template('edit.html', form=form, title=title, tags=tags)
def create_entry(entries: List[schema.Entry]):
db_entries = []
for entry in entries:
db_entry = models.Entry(
goal_id=entry.goal_id,
date=entry.date,
tracked=entry.tracked,
amount=entry.amount,
)
db.session.add(db_entry)
db.session.commit()
db_entries.append(db_entry)
return db_entries
def new_entry():
content = request.get_json()
if valid_entry(content):
new_entry = models.Entry(
entry_date=content.get('entry_date'),
value=content.get('value'),
account=content.get('account'),
tags=content.get('tags'),
description=content.get('description'),
)
new_entry.save()
return jsonify(**new_entry.to_dict()), 201
else:
return jsonify({'status': 'Bad Request'}), 400
def _CleanEntryBase(feed_entity, entry_feedparser, content, original_content):
try:
updated = datetime.datetime(*entry_feedparser.updated_parsed[:6])
except AttributeError:
updated = datetime.datetime.now()
entry_entity = models.Entry(
key_name=_EntryId(entry_feedparser),
feed=feed_entity,
title=entry_feedparser.title.replace('\n', '').replace('\r', ''),
link=entry_feedparser.link,
updated=updated,
content=content,
original_content=original_content)
entry_entity.put()
def add():
"""Creates new entry from data provided in AddEntryForm"""
form = forms.AddEntryForm()
if form.validate_on_submit():
# creates new entry with data inputed in form by user
try:
entry = models.Entry()
update_from_form(entry, form)
except models.IntegrityError:
flash("The entry with that title already exists", "error")
return redirect(url_for('add'))
# creates or gets tags inputed in form and
# creates their relationship with entry
tags_from_string(form.tags.data, entry)
flash("New entry successfully made", "success")
return redirect(url_for('index'))
return render_template('new.html', title="New Entry", form=form)
def api():
auth = request.headers.get('Authorization')
if auth != app.config['APIKEY']:
return json.dumps({'success': False, 'message': 'Not authorized'}), 400
data = request.get_json(force=True)
if not data:
return json.dumps({'success': False, 'message': 'JSON data not found '
'or mimetype not set'}), 400
try:
entry = m.Entry(
username=data.get('username'),
entry_type=data.get('type'),
entry_text=data.get('text')
)
except m.ValidationError:
return json.dumps({'success': False, 'message': 'Validation error with'
' the data provided'}), 400
db.session.add(entry)
db.session.commit()
return json.dumps({'success': True})
def new_view():
"""
The new view returns a page allowing a new entry to be
created
"""
if request.method == 'POST':
# Now we get the "posted" inputs from the webpage
# and add them back into the entry
entry = models.Entry(
title=request.form['title'],
date=datetime.datetime.fromisoformat(
request.form['date']),
time_spent=request.form['time_spent'],
learned=request.form['learned'],
resources=request.form['resources'],
tags=request.form['tags']
)
entry.save()
return redirect('/entries/{}'.format(entry.slug))
return render_template("new.html")
def get_entry_from_request(request):
if decode(request.get("type")) == "product":
dependency = models.Entry.get(decode(request.get("dependency")))
due_on = dependency.due_on
else:
due_on = iso_to_date(decode(request.get("due_on")))
entry = models.Entry(
name=decode(request.get("name")),
notes=decode(request.get("notes")),
impact=decode(request.get("impact")),
project=models.Project.get(decode(request.get("project"))),
due_on=due_on,
type=decode(request.get("type")),
prod_design_doc=decode(request.get("prod_design_doc")),
eng_design_doc=decode(request.get("eng_design_doc")),
mktg_doc=decode(request.get("mktg_doc")))
if entry.type == "product":
entry.dependency = models.Entry.get(decode(request.get("dependency")))
elif entry.type == "platform" and decode(request.get("prelude_to")):
entry.prelude_to = models.Entry.get(decode(request.get("prelude_to")))
return entry
def insert_entry(self, entry, taxids):
"""
insert UniProt entry"
:param entry: XML node entry
:param taxids: int,tuple,list taxids: NCBI taxonomy IDs
:return:
"""
entry_dict = entry.attrib
entry_dict['created'] = datetime.strptime(entry_dict['created'],
'%Y-%m-%d')
entry_dict['modified'] = datetime.strptime(entry_dict['modified'],
'%Y-%m-%d')
#print(entry_dict['created'])
taxid = self.get_taxid(entry)
if taxids is None or taxid in taxids:
#entry_dict = self.update_entry_dict(entry, entry_dict, taxid)
entry_obj = models.Entry(**entry_dict)
del entry_dict
def create():
form = PostForm()
if form.validate_on_submit():
image_id = None
if form.featured_image.data:
f = form.featured_image.data
image_id = str(uuid.uuid4())
file_name = image_id + '.png'
file_path = os.path.join(app.config['UPLOAD_FOLDER'], file_name)
Image.open(f).save(file_path)
duplicate_title = False
all_post = models.Entry.query.all()
serialized_data = [data.serialize() for data in all_post]
for i in serialized_data:
if form.title.data == i['title']:
duplicate_title = True
break
if duplicate_title:
return 'Sorry, This Post title has already been used. Kindly use another'
post = models.Entry(title=form.title.data,
subtitle=form.subtitle.data,
content=form.content.data,
author=current_user,
featured_image=image_id,
category=form.category.data)
models.Entry.save(post)
flash('Your post is now live!')
return redirect(url_for('create'))
return render_template("test.html",
form=form,
legend='New Post',
submit='Publish',
staff_id=current_user.id)
def test_one_entry(self):
e = models.Entry(title='Test', text='Test text')
e.put()
rv = self.app.get('/')
assert 'No entries here so far' not in rv.data
def paypal_notification():
''' Listener for PayPal notification '''
notification = request.form.to_dict()
notification['cmd'] = '_notify-validate'
headers = {
'content-type': 'application/x-www-form-urlencoded',
'host': 'www.paypal.com'
}
validation_response = requests.post(
PAYPAL_PRODUCTION,
data=notification,
headers=headers,
verify=True)
validation_response.raise_for_status()
valid_txn_types = ('subscr_payment', 'web_accept', )
txn_type = notification.get('txn_type')
if validation_response.text == 'VERIFIED' and txn_type in valid_txn_types:
full_name = ' '.join([
notification.get('first_name', ''),
notification.get('last_name', ''),
])
value = notification.get('mc_gross', '0')
tax_value = '-{}'.format(notification.get('mc_fee', '0'))
payment_date = notification.get('payment_date', '')
match = re.findall('[A-Za-z]{3} [0-9]{2}, [0-9]{4}', payment_date)
if match:
raw_payment_date = match.pop()
entry_date = datetime.datetime.strptime(raw_payment_date, '%b %d, %Y')
entry_date = entry_date.strftime('%Y-%m-%d')
account = '_paypal'
description = '{} - {}'.format(
notification.get('item_name'),
full_name)
tax_description = 'Taxa - {}'.format(description)
tags_map = {
'camiseta-30': 'camisetas',
'lhc-85': 'mensalidade',
'lhc-110': 'mensalidade',
'lhc-60': 'mensalidade',
'lhc-30': 'contribuicao',
'doacao-lhc': 'doacao',
}
tags = tags_map.get(notification.get('item_number', ''), '')
entry = models.Entry(
entry_date=entry_date,
value=value,
account=account,
tags=tags,
description=description
)
entry.save()
tax_entry = models.Entry(
entry_date=entry_date,
value=tax_value,
account=account,
tags='taxa,{}'.format(tags),
description=tax_description
)
tax_entry.save()
return ''
def test_entry(self):
m = models.Entry(title='Test', text='Test entry text')
m.put()
self.assertIsNotNone(m.last_updated_date)
import os
import flask
from flask import request, session
from flask import redirect, flash
import models
REGISTRY = [
models.Entry('0x0001', 'NL-123456789'),
models.Entry('0x0002', 'NL-198854321'),
models.Entry('0x0003', 'NL-987654321'),
]
app = flask.Flask(__name__)
app.config.from_object(__name__) # load config from this file
# Session key
app.config.update(dict(SECRET_KEY='development key'))
# skip DB setup for now
#app.config.update(dict(
#DATABASE=os.path.join(app.root_path, 'flaskr.db'),
#USERNAME='******',
#PASSWORD='******'
#))
# Optional environment settings
app.config.from_envvar('MOCKUP_SETTINGS', silent=True)
@app.route('/favicon.ico')
def favicon():
def add_entry():
entry = models.Entry(title=flask.request.form['title'],
text=flask.request.form['text'])
entry.put()
flask.flash('New entry was successfully posted')
return flask.redirect(flask.url_for('show_entries'))
"""Prepopulate New Entry form with data from database in
edit.html template and submit changes to database"""
entry = models.Entry.get(models.Entry.id == entry_id)
form = forms.EntryForm(obj=entry)
if form.validate_on_submit():
models.Entry.update(
title=form.title.data.strip(),
date=form.date.data,
time_spent=form.time_spent.data.strip(),
resources_to_remember=form.resources_to_remember.data.strip(),
what_i_learned=form.what_i_learned.data.strip()).where(
models.Entry.id == entry_id).execute()
flash("Message posted! Thanks!", "success")
return redirect(url_for('entries'))
return render_template('edit.html', form=form)
@app.route('/entries/delete/<int:entry_id>')
def delete_entry(entry_id):
"""Delete entry from database by clicking on hyperlink"""
models.Entry.get(models.Entry.id == entry_id).delete_instance()
return redirect(url_for('entries'))
if __name__ == '__main__':
try:
models.Entry().initialize()
except ValueError:
pass
app.run(debug=DEBUG, host=HOST, port=PORT)
