def db_insert_test_data(app):
with app.app_context():
init_db()
db = get_db()
test_user = User(
username='******',
password_hash=
'pbkdf2:sha256:50000$TCI4GzcX$0de171a4f4dac32e3364c7ddc7c14f3e2fa61f2d17574483f7ffbb431b4acb2f',
first_name='TestUserFirstName',
last_name='TestUserLastName',
)
other_user = User(
username='******',
password_hash=
'pbkdf2:sha256:50000$kJPKsz6N$d2d4784f1b030a9761f5ccaeeaca413f27f2ecb76d6168407af962ddce849f79',
first_name='OtherUserFirstName',
last_name='OtherUserLastName',
)
test_post = Post(
author_id=1,
created=datetime.fromisoformat('2020-01-01 00:00:00'),
title='test title',
body='test\nbody',
)
other_post = Post(
author_id=2,
created=datetime.fromisoformat('2020-02-01 00:00:00'),
title='other title',
body='other\nbody',
)
db.session.add_all((test_user, other_user, test_post, other_post))
db.session.commit()
def insert_post(title, body, filename, user_id, tags=[]):
post = Post(title=title, body=body, image_path=filename, author_id=user_id)
db.session.add(post)
if len(tags) > 0:
db_tags = get_persistent_tags(tags)
post.tags = db_tags
db.session.commit()
return post.id
def post():
form = PostForm(request.form)
if request.method == 'POST' and form.validate():
title = form.title.data
content = form.content.data
due_date = form.due_date.data
posts = Post(title, content, due_date)
posts.add_post()
return redirect(url_for('app.todohome'))
return render_template('post.html', form=form)
def post(page_id):
form = PostForm(request.form)
page_id = page_id
if request.method == 'POST' and form.validate():
content = form.content.data
username = form.username.data
page_id = form.page_id.data
time = datetime.datetime.now()
post = Post(content, username, time, page_id)
post.add_post()
flash('新しく投稿しました！')
return redirect(url_for('app.user_page'))
return render_template('post.html', form=form, page_id=page_id)
def create():
"""Create a new post for the current user."""
if request.method == 'POST':
title = request.form['title']
body = request.form['body']
error = None
if not title:
error = 'Title is required.'
if error is not None:
flash(error)
else:
# for u, a in session.query(User, Address).
# filter(User.id==Address.user_id).\
#filter(Address.email_address=='*****@*****.**').\ all():
u1 = g.user.id
u = db_session.query(User).filter(User.id == u1).first()
# p = Post( title, body, g.user['id'] )
# Post(user_id=None , user = None ,created =None, body=None )
# Post(title =title , body=body)
# user = u ,
p = Post(title=title, body=body)
u.posts = [p]
#db_session.add(p)
db_session.commit()
return redirect(url_for('blog.index'))
return render_template('blog/create.html')
def get_post(id):
try:
instance = Post.get(Post.id == id)
except Post.DoesNotExist:
return jsonify({'data': 'NotFound'}, status=404)
return instance
def create():
if request.method == 'POST':
title = request.form['title']
body = request.form['body']
error = None
if not title:
error = 'Title is required.'
if error is not None:
flash(error)
else:
# mysql
post = Post(title, body, g.user.id)
db_session.add(post)
db_session.commit()
# sqlite3
# db = get_db()
# db.execute(
# 'INSERT INTO post (title, body, author_id)'
# ' VALUES (?, ?, ?)',
# (title, body, g.user['id'])
# )
# db.commit()
return redirect(url_for('blog.index'))
return render_template('blog/create.html')
def get_all_posts():
"""
Get all posts available in database.
:return: Flask `Response` object with added JSON representation of all `Post`
objects available and `Content-Type: application/json` HTTP header.
"""
return jsonify(Post.to_collection_dict())
def create():
data = request.json
if not data.get('title'):
return jsonify({'error': 'Title is required.'})
data['user_id'] = g.user.id
instance = Post.create(**data)
return jsonify(model_to_dict(instance, exclude=[Post.user.password]))
def create():
if request.method == 'POST':
body = request.form['body']
post = Post(body=body, author=g.user)
db_session.add(post)
db_session.commit()
return redirect(url_for('blog.index'))
return render_template('blog/create.html')
def test_follow_posts(self):
# create four users
u1 = User(username='******', email='*****@*****.**')
u2 = User(username='******', email='*****@*****.**')
u3 = User(username='******', email='*****@*****.**')
u4 = User(username='******', email='*****@*****.**')
db.session.add_all([u1, u2, u3, u4])
# create four posts
now = datetime.utcnow()
p1 = Post(body="post from john",
author=u1,
timestamp=now + timedelta(seconds=1))
p2 = Post(body="post from susan",
author=u2,
timestamp=now + timedelta(seconds=4))
p3 = Post(body="post from mary",
author=u3,
timestamp=now + timedelta(seconds=3))
p4 = Post(body="post from david",
author=u4,
timestamp=now + timedelta(seconds=2))
db.session.add_all([p1, p2, p3, p4])
db.session.commit()
# setup the followers
u1.follow(u2) # john follows susan
u1.follow(u4) # john follows david
u2.follow(u3) # susan follows mary
u3.follow(u4) # mary follows david
db.session.commit()
# check the followed posts of each user
f1 = u1.followed_posts().all()
f2 = u2.followed_posts().all()
f3 = u3.followed_posts().all()
f4 = u4.followed_posts().all()
self.assertEqual(f1, [p2, p4, p1])
self.assertEqual(f2, [p2, p3])
self.assertEqual(f3, [p3, p4])
self.assertEqual(f4, [p4])
def load_posts():
test_user = User.query.filter(User.username == "test").first()
post1 = Post(
title="test title",
body="test body without image",
image_path="test_image.jpg",
author_id=test_user.id,
created=datetime(2020, 1, 1, 15, 17, tzinfo=timezone.utc),
)
db.session.add(post1)
for i in range(10):
db.session.add(
Post(
title="post without image - " + str(i),
body="test body without image",
author_id=test_user.id,
created=datetime(2019, 5, 18, (15 - i), 17, tzinfo=timezone.utc),
)
)
db.session.commit()
def new_post():
form = PostForm()
if form.validate_on_submit():
post = Post(title=form.title.data, contest_url=form.url.data,
content=form.content.data,
author=current_user, contest_date=form.date.data)
db.session.add(post)
db.session.commit()
flash('Your post has been created!', 'success')
return redirect(url_for('home'))
return render_template('create_post.html',
title='New Post', form=form, legend='New Post')
def test_create_db(app, runner):
result = runner.invoke(args=['create-db'])
assert 'database created' in result.output
with app.app_context():
user = User(name='testing')
user.set_password('testing')
post = Post(title='testing', body='testing')
post.author = user
db.session.add_all([user, post])
db.session.commit()
users = User.query.all()
posts = Post.query.all()
assert len(users) == 1
assert len(posts) == 1
result = runner.invoke(args=['create-db', '--force'])
assert 'old database dropped' in result.output
with app.app_context():
users = User.query.all()
posts = Post.query.all()
assert len(users) == 0
assert len(posts) == 0
def newpost():
form = PostForm()
if (form.validate_on_submit()):
post = Post(title=form.title.data,
content=form.content.data,
author=current_user)
db.session.add(post)
db.session.commit()
return redirect(url_for('home'))
return render_template('create_post.html',
title='New Post',
form=form,
legend='Create Post')
def app():
app = create_app(TestConfig)
with app.app_context():
db.drop_all()
db.create_all()
user1 = User(username='******', password=generate_password_hash('test'))
user2 = User(username='******',
password=generate_password_hash('test2'))
db.session.add_all([user1, user2])
db.session.commit()
post = Post(title='test title',
body='test',
created='2018-01-01 00:00:00',
author_id=1)
db.session.add(post)
db.session.commit()
yield app
def create():
"""Create a blog post and redirect to main page."""
if request.method == 'POST':
title = request.form['title']
body = request.form['body']
error = None
if not title:
error = 'Title is required.'
if error is not None:
flash(error)
else:
db = get_db()
post = Post(title=title, body=body, author_id=g.user.id_)
db.session.add(post)
db.session.commit()
return redirect(url_for('blog.index'))
return render_template('blog/create.html')
def create():
if request.method == 'POST':
title = request.form['title']
body = request.form['body']
error = None
print(g.user)
if not title:
error = 'Title is required.'
if error is not None:
flash(error)
else:
post = Post(title=title, body=body, author_id=session["user_id"])
db.session.add(post)
db.session.commit()
return redirect(url_for('blog.index'))
return render_template('blog/create.html')
def app():
db_fd, db_path = tempfile.mkstemp()
app = create_app({
'TESTING': True,
'DATABASE': db_path,
'WTF_CSRF_ENABLED': False,
})
with app.test_client() as client:
client.get('/')
g.session.add_all(User(**user) for user in USERS)
g.session.add_all(Post(**post) for post in POSTS)
yield app
os.close(db_fd)
os.unlink(db_path)
def create():
if request.method == 'POST':
title = request.form['title']
body = request.form['body']
error = None
if not title:
error = 'Title is required.'
if error is not None:
flash(error)
else:
data = Post(current_user.id, title, body)
db.session.add(data)
db.session.commit()
return redirect(url_for('blog.index'))
return render_template('blog/create.html')
def create():
if request.method == "POST":
title = request.form["title"]
body = request.form["body"]
error = None
if not title:
error = "Title is required."
if error is not None:
flash(error)
else:
post = Post(title=title, body=body, author_id=g.user.id)
db.session.add(post)
db.session.commit()
return redirect(url_for("blog.index"))
return render_template("blog/create.html")
def create():
if request.method == 'POST':
title = request.form.get('title')
body = request.form.get('body')
error = None
if not title:
error = 'Title is required.'
if error is not None:
flash(error)
else:
post = Post(title=title,
body=body,
author_id=current_user.get_id())
db.session.add(post)
db.session.commit()
return redirect(url_for('blog.index', _external=True))
return render_template('blog/create.html')
def post_create():
if request.method == 'POST':
title = request.form["title"]
body = request.form["body"]
categories = request.form.getlist("categories")
category_data = []
for category in categories:
tmp = Category.query.filter(Category.name == category).first()
category_data.append(tmp)
print(category_data)
post = Post(title=title,
body=body
)
for category in category_data:
post.categories.append(category)
db.session.add(post)
db.session.commit()
return redirect(url_for('post_list'))
categories = Category.query.all()
return render_template('post/edit.html', categories=categories)
def app():
"""Create and configure a new app instance for each test."""
# create the app with common test config
app = create_app({
'TESTING': True,
'SQLALCHEMY_DATABASE_URI': 'sqlite:///:memory:',
})
# create the database and load test data
with app.app_context():
db.create_all()
user1 = User(username='******', password=generate_password_hash('test'))
user2 = User(username='******',
password=generate_password_hash('other'))
post = Post(title='test title',
body=('test\nbody'),
author_id=1,
created=datetime(2018, 1, 1))
db.session.add_all([user1, user2, post])
db.session.commit()
yield app
def index():
form = PostForm()
if form.validate_on_submit():
post = Post(body=form.post.data, author=current_user)
print(form.post.data, post.author)
db.session.add(post)
db.session.commit()
flash('Your post is now live!')
return redirect(url_for('index'))
page = request.args.get('page', 1, type=int)
posts = current_user.followed_posts().paginate(
page, app.config['POSTS_PER_PAGE'], False)
next_url = url_for('index',
page=posts.next_num) if posts.has_next else None
prev_url = url_for('index',
page=posts.prev_num) if posts.has_prev else None
return render_template('index.html',
title='Home',
form=form,
posts=posts.items,
next_url=next_url,
prev_url=prev_url)
def create_post(self):
post = Post(author_id=self.user.id, **post_data)
db.session.add(post)
db.session.commit()
return post
def posts():
qs = Post.select()
result = []
for item in qs:
result.append(model_to_dict(item, exclude=[Post.user.password]))
return jsonify(result)
def delete_user_post(id):
user = User.query.filter_by(username=get_jwt_identity()).first_or_404()
post = Post().query.filter_by(user=user, id=id).first_or_404()
db.session.delete(post)
db.session.commit()
return '', 204 # No Content
def get_user_posts():
user = User.query.filter_by(username=get_jwt_identity()).first_or_404()
query = Post().query.filter_by(user=user).order_by(get_sort(request))
return jsonify(render_paginator(request, PostSchema, query)), 200 # OK
def index(page=1):
try:
registerform = RegistrationForm()
if registerform.validate_on_submit():
checkUsername = registerform.username.data
checkEmail = registerform.email.data
hashed_password = bcrypt.generate_password_hash(
registerform.password.data).decode('utf-8')
user = User(username=registerform.username.data,
email=registerform.email.data,
password=hashed_password)
usernameExists = db.session.query(
db.session.query(User).filter_by(
username=checkUsername).exists()).scalar()
emailExists = db.session.query(
db.session.query(User).filter_by(
email=checkEmail).exists()).scalar()
if usernameExists or emailExists:
message = 'That username or email is already taken'
flash(str(message), 'loginError')
return redirect("/")
return render_template('index.html', loginError=loginError)
else:
db.session.add(user)
db.session.commit()
message = 'Registration succesfull!'
flash(str(message), 'loginError')
return redirect("/")
return render_template('index.html', loginError=loginError)
return redirect("/")
return render_template('index.html', loginError=loginError)
loginform = LoginForm()
if loginform.validate_on_submit():
user = User.query.filter_by(email=loginform.email.data).first()
if user and bcrypt.check_password_hash(user.password,
loginform.password.data):
login_user(user, remember=loginform.remember.data)
#next_page = request.args.get('next')
#return redirect(next_page) if next_page else redirect(url_for('index'))
return redirect(url_for('/'))
else:
message = 'Invalid login, please check your login values and try again'
flash(str(message), 'loginError')
return redirect("/")
return render_template('index.html', loginError=loginError)
if current_user.is_authenticated:
userfolder = current_user.username
converteduserfiles = []
userfiles = []
path = f'files/{userfolder}/'
if (os.path.exists(f'files/{userfolder}/converted')):
pathtoconverted = f'files/{userfolder}/converted'
else:
if not (os.path.exists(f'files/{userfolder}')):
os.mkdir(f'files/{userfolder}')
os.mkdir(f'files/{userfolder}/converted')
pathtoconverted = f'files/{userfolder}/converted'
for filename in os.listdir(path):
if os.path.isfile and filename != 'converted':
userfiles.append(filename)
for filename in os.listdir(pathtoconverted):
if os.path.isfile:
converteduserfiles.append(filename)
else:
filename = ''
path = ''
userfiles = '', ''
converteduserfiles = ''
pathtoconverted = ''
session['filename'] = filename
session['path'] = path
session['userfiles[]'] = userfiles
session['converteduserfiles[]'] = converteduserfiles
session['pathtoconverted'] = pathtoconverted
session['filename'] = filename
session['path'] = path
session['userfiles[]'] = userfiles
session['converteduserfiles[]'] = converteduserfiles
session['pathtoconverted'] = pathtoconverted
postform = PostForm()
if postform.validate_on_submit():
post = Post(title=postform.title.data,
content=postform.content.data,
author=current_user)
db.session.add(post)
db.session.commit()
flash('Your post has been created!', 'success')
return redirect(url_for('index'))
RESULTS_PER_PAGE = 5
#posts = Post.query.all()
#models.Post.query.paginate(page, per_page, error_out=False)
#posts = Post.query.order_by(Post.id.title()).paginate(page,per_page,error_out=False)
posts = models.Post.query.paginate(page, RESULTS_PER_PAGE, False)
num = int(ceil(float(posts.total) / RESULTS_PER_PAGE)) + 1
environment = jinja2.Environment(os)
environment.filters['os'] = os
#{% for post in posts|sort(attribute='date_posted', reverse=true) %}
return render_template(
'index.html',
title='Account',
loginform=loginform,
registerform=registerform,
postform=postform,
posts=posts,
number_of_pages=num,
userfiles=session['userfiles[]'],
path=session['path'],
filename=session['filename'],
pathtoconverted=session['pathtoconverted'],
converteduserfiles=session['converteduserfiles[]'],
os=os)
#All exception catchers, most of these will never happen but they're there just to be sure.
except KeyError as a:
flash(str(a), 'error')
return redirect("/")
return render_template('index.html', error=error)
session.pop('_flashes', None)
except NameError as b:
flash(str(b), 'error')
return redirect("/")
return render_template('index.html', error=error)
session.pop('_flashes', None)
except ValueError as c:
flash(str(c), 'error')
return redirect("/")
return render_template('index.html', error=error)
session.pop('_flashes', None)
except TypeError as f:
flash(str(f), 'error')
return redirect("/")
return render_template('index.html', error=error)
session.pop('_flashes', None)
except:
#message = 'You broke my webapp somehow, if this is a recurring error then please contact the developer'
#flash(str(message), 'error')
return redirect("/")
#return render_template('index.html', error=error)
return render_template('index.html')
session.pop('_flashes', None)
