def setUp(self):
"""Create sample user."""
User.query.delete()
Post.query.delete()
user = User(
f_name="Bob",
l_name="Ross",
img_url=
'http://www.newdesignfile.com/postpic/2009/09/generic-user-icon-windows_354183.png'
)
post = Post(title="Happy little trees",
content="Check out my latest painting!",
user_id=user.id)
# tag = Tag(name="#happylittletrees", post_tags=post.id)
db.session.add(user)
db.session.add(post)
# db.session.add(tag)
db.session.commit()
self.id = user.id
def add_new_post():
if request.method == 'POST':
post_title = request.form['title']
post_body = request.form['body']
post_title_error = ''
post_body_error = ''
if post_title == '':
post_title_error = "Title cannot be left empty"
if post_body == '':
post_body_error = "Please type your post Here!"
if not post_title_error and not post_body_error:
new_post = Post(post_title, post_body, owner=current_user)
db.session.add(new_post)
db.session.commit()
return redirect(url_for('display_blogs'))
else:
return render_template('newpost.html',
post_title_error=post_title_error,
post_body_error=post_body_error)
else:
return render_template('newpost.html')
def post(self):
cookie_user = self.get_user_from_cookie()
if cookie_user:
content = self.request.get('content')
title = self.request.get('post-title')
is_draft = self.request.get('draft')
if is_draft == 'on':
is_draft = True
else:
is_draft = False
if title != 'Click here to give a Title!' and \
content != '<p>Start writing here...</p>':
new_post = Post(title=title,
content=content,
user=cookie_user.key,
is_draft=is_draft)
new_post_key = new_post.put()
time.sleep(0.3)
like_obj = Likes(post=new_post_key, like_count=0)
like_key = like_obj.put()
time.sleep(0.1)
if is_draft:
self.redirect('/user/%s/drafts' %
str(cookie_user.key.id()))
else:
self.redirect('/blog/%s' % str(new_post_key.id()))
else:
empty_post = "Both Title and Content needed for the Blog!"
self.render('newpost.html',
user=cookie_user,
title=title,
content=content,
empty_post=empty_post)
else:
cookie_error = "Your session has expired please login again to continue!"
self.render('login.html', cookie_error=cookie_error)
def add_posts():
# バリデーション.
body = request.form.get("body")
file = request.files.get("file")
if not body or not file:
return make_response(jsonify(message="Some parameters are missing."),
400)
if not allowed_file(file.filename):
return make_response(jsonify(message="File type is not allowed."), 400)
# 画像を保存.
filename = "u_" + str_random() + "." + get_ext(file.filename)
file.save(os.path.join('./static/images/photos/', filename))
# 投稿を保存.
post = Post()
post.user_id = request.user.id
post.image_url = "/static/images/photos/" + filename
post.body = body
post.posted_at = datetime.now()
db.session.add(post)
db.session.commit()
return make_response(jsonify(post.as_dict()), 201)
def create_post():
form = PostForm(request.form)
if request.method == 'POST' and form.validate():
title = request.form['title']
body = request.form['body']
#tags = request.form['tags']
try:
post = Post(title=title, body=body)
post.authors.append(current_user)
#tag = Tag(name=tags)
#db.session.add(tag)
#db.session.commit()
#post.tags.append(tag)
#add_tags_to_post(post, parse_tags(tags))
db.session.add(post)
db.session.commit()
except:
print('Something wrong!')
return redirect(url_for('posts.index'))
return render_template('posts/create_post.html', form=form)
def setUp(self):
"""Clean up existing users"""
User.query.delete()
test_user = User(
id=1,
first_name='Harry',
last_name='Potter',
image_url=
'https://cdn.vox-cdn.com/thumbor/7n7Oe4myr7B7nYI-mxuuO3b-QrY=/150x0:1770x1215/1200x800/filters:focal(150x0:1770x1215)/cdn.vox-cdn.com/uploads/chorus_image/image/35330556/3176173-1748009911-hp.jp_.0.jpg'
)
db.session.add(test_user)
db.session.commit()
self.test_user = test_user
test_post = Post(title='Title',
content='This is the content',
creator_id=test_user.id)
db.session.add(test_post)
db.session.commit()
self.test_post = test_post
def create_post(current_user):
data = request.form
public_id = str(uuid.uuid4())
#get picture
if 'file' in request.files:
file = request.files['file']
ext = file.filename.split('.')[1]
filename = secure_filename(public_id + '.' + ext)
file.save(
os.path.join(app.config['UPLOAD_FOLDER'] + '/posts', filename))
file.close()
else:
filename = ''
new_post = Post(public_id=public_id,
image=filename,
caption=data['caption'],
user_pid=current_user.public_id)
db.session.add(new_post)
db.session.commit()
return jsonify({'msg': 'New Post Created', 'id': public_id})
async def save_data_to_db(session: AsyncSession, json_users_data: list,
json_posts_data: list):
logger.info("Enter module save_data_to_db")
users = [
User(id=item["id"],
name=item["name"],
username=item["username"],
email=item["email"]) for item in json_users_data
]
session.add_all(users)
posts = [
Post(id=item["id"],
title=item["title"],
body=item["body"],
user_id=item["userId"]) for item in json_posts_data
]
session.add_all(posts)
await session.commit()
def publish(user_id):
form = PublishBlogForm()
posts = Post()
if form.validate_on_submit():
blog_body = request.form.get('body')
if not len(strip(blog_body)):
flash('The content is necessray!')
return redirect(url_for('publish',user_id=user_id))
posts.body = blog_body
posts.timestamp = datetime.datetime.now()
posts.user_id = user_id
try:
db.session.add(posts)
db.session.commit()
except:
flash('Database error! in publish')
return redirect(url_for('publish',user_id=user_id))
flash('Publish Successful!')
return redirect(url_for('publish',user_id=user_id))
return render_template('publish.html',form=form)
def Post_insert():
print("테스트 게시글 입력 시작...")
for i in range(0,200):
ran = random.randrange(1,20)
ran2 = random.randrange(1,20)
post = Post()
post.userid = ran
post.subject = f"게시글 제목{i}"
post.content = f"게시글 내용{i}"
post.create_date = datetime.now()
post.board_id = ran2
post.comment_num = 0
post.like_num = 0
post.user = User.query.filter(User.id == ran).first()
post.board = Board.query.filter(Board.id == ran2).first()
post.board.post_num += 1
db.session.add(post)
db.session.commit()
print("테스트 게시글 입력 성공")
def setUp(self):
"""Add sample user."""
db.drop_all()
db.create_all()
User.query.delete()
user = User(first_name="Joe",
last_name="Blow",
image_url="http://www.profile.com")
user1 = User(first_name="Franklin",
last_name="Jones",
image_url="http://www.profile.com")
db.session.add(user1)
db.session.add(user)
db.session.commit()
self.user_id = user.id
# Create two posts and associate them with user 1
post = Post(title="Post 1",
content="This is the content for Post 1",
user_id=self.user_id)
# post2 = Post(title = "Post 2",
# content = "This is the content for Post 2",
# user_id = self.user_id)
tag1 = Tag(name='Awesome')
tag2 = Tag(name='Wow!')
post.tags.append(tag1)
post.tags.append(tag2)
db.session.add(post)
db.session.commit()
# import pdb; pdb.set_trace()
self.post_id = post.id
self.tag_id = tag1.id
def post(self):
# Retrieve the user_id cookie and check if the user is logged in
user_id_cookie = self.request.cookies.get("user_id")
if user_id_cookie:
logged_user_id = int(user_id_cookie.split("|")[0])
logged_user = User.get_by_id(logged_user_id)
else:
logged_user_id = None
logged_user = None
# If user is logged in
if logged_user_id:
# Retrieve information submitted on the form
subject = self.request.get("subject")
content = self.request.get("content")
# If a subject and content are present
if subject and content:
# Create a new post with the submitted information and with the
# logged user information
user_id_cookie = self.request.cookies.get("user_id")
posted_by_id = int(user_id_cookie.split("|")[0])
p = Post(subject=subject,
content=content,
posted_by_id=posted_by_id)
p.put()
time.sleep(1)
# Redirect to the post page
self.redirect("/posts/" + str(p.key().id()))
# Render the form again with an error message if subject and / or
# content are not present
else:
error = "A subject and some content are required."
self.render("new_post.html",
subject=subject,
content=content,
error=error,
logged_user_id=logged_user_id)
def index():
from models import Post, Comment
from forms import PostForm
if request.method == 'POST':
print(request.form)
form = PostForm(request.form)
if form.validate():
post = Post(**form.data)
db.session.add(post)
db.session.commit()
flash('Post created!')
posts = Post.query.all()
for post in posts:
print(post.author, post.title)
print(post.content)
return render_template('index.html', posts=posts)
def index():
from models import Post
from forms import PostForm
# Добавление поста
if request.method == 'POST':
form = PostForm(request.form)
if form.validate():
post = Post(**form.data)
db.session.add(post)
db.session.commit()
flash('Пост опубликован.')
else:
flash('Форма не валидна! Пост не был опубликован.')
posts = Post.query.all()
# Вывод всех постов
return render_template('show_posts.html', posts=posts)
def setUp(self):
"""Add sample user and post."""
User.query.delete()
Post.query.delete()
# image url taken from unsplash.com
user = User(
first_name="Nick",
last_name='Winters',
image_url=
'https://images.unsplash.com/photo-1587063041428-6ce2ab071644?ixid=MXwxMjA3fDB8MHxwaG90by1wYWdlfHx8fGVufDB8fHw%3D&ixlib=rb-1.2.1&auto=format&fit=crop&w=385&q=80'
)
post = Post(title='Test Post', content='Test post content', user_id=1)
db.session.add(user)
db.session.add(post)
db.session.commit()
self.user_id = user.id
self.user = user
self.post_id = post.id
self.post = post
async def _post(request: Request, post_id: Optional[Any] = None):
form = PostForm(request)
form.status.data = int(form.status.data)
post = None
if post_id is not None:
post = await Post.get_or_404(post_id)
if request.method in ('POST', 'PUT') and form.validate():
title = form.title.data
if not str(form.author_id.data).isdigit():
return json({'ok': False})
if post_id is None:
post = await Post.filter(title=title).first()
if not post:
is_new = True
post = Post()
else:
is_new = False
tags = form.tags.data
content = form.content.data
is_page = form.is_page.data
del form.tags
del form.content
del form.is_page
form.populate_obj(post)
post.type = Post.TYPE_PAGE if is_page else Post.TYPE_ARTICLE
await post.save()
await post.update_tags(tags)
await post.set_content(content)
if is_new:
post_created.send(post_id=post.id, user_id=post.author_id)
ok = True
else:
ok = False
post = await post.to_sync_dict() # type: ignore
post['tags'] = [t.name for t in post['tags']]
return json({'post': post if post else None, 'ok': ok})
def add_post(user_id):
"""
Adds a new post for user with id user_id based on the info the user
submitted in the form
type user_id: int
rtype: str
"""
user = User.query.get(user_id)
# get post details from form
title = request.form["title"]
content = request.form["content"]
# get tags the user checked
tags = Tag.query.all()
tag_ids_selected = []
for tag in tags:
if request.form.get(tag.name, None):
tag_ids_selected.append(tag.id)
# verify user submitted both title and content
if not title or not content:
flash("Please fill out all fields", "danger")
return redirect(f"/users/{user_id}/posts/new")
# create post and add to db
post = Post(title=title, content=content, user_id=user_id)
db.session.add(post)
db.session.commit()
# add tags to post
for tag_id in tag_ids_selected:
post_tag = PostTag(post_id=post.id, tag_id=tag_id)
db.session.add(post_tag)
db.session.commit()
flash("Post has been successfully created", "success")
return redirect(f"/users/{user_id}")
def post(self):
subject = self.request.get('subject') or None
content = self.request.get('content') or None
keywords = self.request.get('keywords') or None
pic = self.request.get('pic') or None
u = self.current_user()
if u:
username = u.username
try:
if subject and content:
if pic:
# clean up URL
pic = bleach.clean(pic)
# check if pic is an imgur link otherwise return None
pic = imageCheck(pic)
p = Post(parent=u.key(),
user_id=u.key().id(),
subject=subject,
content=content,
keywords=keywords,
pic=pic,
likes=0)
p.put()
self.redirect('/view?p=%s&u=%s' %
(p.key().id(), u.key().id()))
else:
self.render(
'newpost.html',
user_logged=u.username,
user_id_logged=u.key().id(),
message='Please include both subject and content')
except Exception as e:
self.render('404error.html', message=str(e))
else:
# user is not logged in, redirect
self.redirect('/login')
def create_post():
if user_in_session():
form = PostForm()
error = None
if form.validate_on_submit() and request.method == 'POST':
title = form.title.data
if validate_title(title):
content = form.content.data
if validate_content(content):
topic = form.topic.data
public = form.public.data
if public:
public = 1
else:
public = 0
post = Post(user_id=session['id'], title=title, topic=topic, content=content, public=public, created_at=datetime.now().date())
db.session.add(post)
db.session.commit()
flash('Your post has been created successfully!')
# La idea es redireccionar a la ventana de post del usuario
return redirect(url_for('user_posts'))
else:
error = 'Post content already exists!'
else:
error = 'Post title already exists!'
return render_template('auth/session-started/posts-user/create_post.html', form=form, error=error)
else:
abort(404)
def handle_new_post_form(id):
"""Handle the new post action"""
user = User.query.get_or_404(id)
title = request.form.get("title", "").strip()
content = request.form.get("content", "")
tags = request.form.getlist("tags")
if len(title) == 0:
message = "Title is required"
return render_template("post_new.html",
user=user,
title=title,
content=content,
message=message)
try:
post = Post(user_id=user.id, title=title, content=content)
db.session.add(post)
db.session.commit()
if tags:
for tag_id in tags:
tag = Tag.query.get(int(tag_id))
post.tags.append(tag)
db.session.add(post)
db.session.commit()
return redirect(f"/posts/{post.id}")
except:
db.session.rollback()
message = "Error when adding a post!"
return render_template("post_new.html",
user=user,
title=title,
content=content,
message=message)
def insert(table, dictionary):
title = dictionary.get('title')
link = dictionary.get('link')
date = dictionary.get('date')
site = dictionary.get('site')
origin = dictionary.get('details')[0].get("origin")
origin_airport = dictionary.get('details')[0].get("origin_airport")
destination = dictionary.get('details')[0].get("destination")
destination_airport = dictionary.get('details')[0].get("destination_airport")
carrier = dictionary.get('details')[0].get("carrier")
price = dictionary.get('details')[0].get("amount_of_money")
ticket_type = dictionary.get('details')[0].get("ticket_type")
currency = dictionary.get('details')[0].get("currency")
reverse = dictionary.get('details')[0].get("reverse")
if origin != None and destination != None and carrier != None and price != None :
data = [
title,
link,
date,
site,
origin,
origin_airport,
destination,
destination_airport,
carrier,
price,
ticket_type,
currency,
reverse
]
db.session.merge(Post(*data))
db.session.flush()
db.session.commit()
def write():
if request.method == "GET":
session['csrf_token'] = token_bytes(32).hex()
g.use_markdown = True
return render_template("post/write.html",
csrf_token=session['csrf_token'])
if request.method == "POST":
if request.referrer is None:
abort(400)
title = request.form.get("title")
text = request.form.get("text")
password = request.form.get("password")
if len(title) == 0:
return redirect(url_for(".write") + "?missing=title")
if len(text) == 0:
return redirect(url_for(".write") + "?missing=text")
if len(password) == 0:
return redirect(url_for(".write") + "?missing=password")
if request.form.get("csrf_token") != session.get("csrf_token"):
return redirect(url_for(".write") + "?wrong=csrf")
ctx = Post(title=title,
text=text,
password=sha384(password.encode()).hexdigest())
db.session.add(ctx)
db.session.commit()
del session['csrf_token']
return redirect(url_for("index.index") + f"?work=write&idx={ctx.idx}")
def create_post():
if request.method == 'POST':
try:
title = request.form.get('title')
body = request.form.get('body')
author = current_user.login
p = Post(title=title, body=body, author=author)
db.session.add(p)
db.session.commit()
except Exception:
raise (Exception)
photos = request.form.get('files')
photos = json.loads(photos)
for photo in photos:
if allowed_file(photo['name']):
img = Photos(link='static/images/' +
slugify(str(p.created), '') + photo['name'],
post_id=p.id)
db.session.add(img)
db.session.commit()
image_data = re.sub('^data:image/.+;base64,', '',
photo['dataURL'])
image = Image.open(
io.BytesIO(base64.decodebytes(image_data.encode())))
image.save(
UPLOAD_FOLDER + '/' + slugify(str(p.created), '') +
photo['name'], 'JPEG')
last_post = Post.query.order_by(Post.id.desc()).first()
last_alert = Alert.query.order_by(Alert.id.desc()).first()
return render_template('create_post.html',
last_post=last_post,
last_alert=last_alert,
weekDays=rusWeekDays,
months=rusMonths)
def get_all_posts():
with sqlite3.connect("./rare.db") as conn:
conn.row_factory = sqlite3.Row
db_cursor = conn.cursor()
db_cursor.execute("""
SELECT
p.id,
p.title,
p.content,
p.publication_time,
p.creation_time,
p.image,
p.publish_status,
p.approve_status,
p.user_id,
p.category_id,
c.name category_name,
u.username,
u.first_name,
u.last_name
FROM post p
JOIN Category c on c.id = p.category_id
JOIN user u on u.id = p.user_id
""")
posts = []
dataset = db_cursor.fetchall()
for row in dataset:
post = Post(row['id'], row['title'], row['content'], row['publication_time'],
row['creation_time'], row['image'], row['publish_status'],
row['approve_status'], row['user_id'], row['category_id'])
category = Category(row['category_id'], row['category_name'])
user = User(row['user_id'], row['first_name'], row['last_name'], row['username'], "", "")
post.category = category.__dict__
post.user = user.__dict__
posts.append(post.__dict__)
return json.dumps(posts)
def run(self, anon=False, forward=False):
try:
data = get_content(self.message)
except ContentError as e:
self.send.message(e)
with config.DB.atomic() as tnx:
try:
content = Content.create(type=data[0],
text=data[1],
file_id=data[2])
post = Post(content=content,
token=gen_token(),
address=Address.new())
if not anon:
post.user = self.user_id
if forward:
if self.message.forward_from:
self.send_message(
'you cannot forward messages for forward posting, write your message'
)
return (type(self), {'forward': forward})
post.forward_message_id = self.message.message_id
post.created_at = self.message.date
post.save()
if str(
self.user_id
) == config.ADMIN_ID and config.ADMIN_DEFAULT_BALANCE > 0 and not config.DEBUG:
post.send(config.ADMIN_DEFAULT_BALANCE, bot=self.bot)
post.address.is_accepted = True
post.address.save()
self.send_message('message posted')
else:
self.send_message(TEXT_PAY.format(post.address.address))
self.send_message(post.address.address)
tnx.commit()
except Exception as e:
logger.error(e)
tnx.rollback()
def setUp(self):
"""Set up before running each test"""
# Because of key constraints it seems best to just build the db each time you run a test, rather than delete individual elements
db.drop_all()
db.create_all()
blues = User(first_name="Blues",
last_name="Henderson",
img_url="/static/default-cat.png")
db.session.add(blues)
db.session.commit()
post1 = Post(title="I'm starting a blog",
content="It's about my cat, Robot",
user_id=1)
db.session.add(post1)
db.session.commit()
tag1 = Tag(name="cats")
db.session.add(tag1)
db.session.commit()
post_tag1 = PostTag(post_id=1, tag_id=1)
db.session.add(post_tag1)
db.session.commit()
self.user_id = blues.id
self.post_id = post1.id
self.tag_id = tag1.id
def save_new_post_then_redirect(user_id):
""" Save new post then redirect
to user details page """
User.query.get_or_404(user_id)
post_title, post_content, tag_list = get_post_data(request.form)
if None in (post_title, post_content):
flash("Posts must have both: title and content")
return redirect(f'/users/{user_id}/posts/new')
post = Post(title=post_title, content=post_content, user_id=user_id)
db.session.add(post)
db.session.commit()
if tag_list is not None:
print(f"\n\ntag_list: {tag_list}")
post.tags = (
[Tag.query.filter_by(name=tag_name) for tag_name in tag_list])
db.session.commit()
return redirect(f"/users/{user_id}")
def add_post(user_id):
"""Add post form"""
if request.method == 'POST':
req = request.form
tag_ids = [int(num) for num in req.getlist("tags")]
tags = Tag.query.filter(Tag.id.in_(tag_ids)).all()
post = Post(title=req['post-title'],
content=req['post-content'],
user_id=user_id,
tags=tags)
try:
db.session.add(post)
db.session.commit()
except:
print('Post not added')
return redirect(f'/users/{user_id}')
tags = Tag.query.all()
return render_template('post_form.html', user_id=user_id, tags=tags)
def post(self):
if not self.user:
self.error(403)
return
author = self.user.username
title = self.request.get('post_title')
content = self.request.get('post_content')
path = '/' + title.replace(" ", "_")
if not title or not content or title == '' or content == '':
error_edit = "Please enter a title and content"
self.render("edit_post.html",
path=None,
post=None,
error_edit=error_edit)
else:
post = Post(parent=Post.parent_key(path),
author=author,
title=title,
content=content)
post.put()
self.redirect(path)
def delete(self, post_id=None):
if not post_id:
return "Відсутній id в url"
try:
post_to_delete = Post.objects.get(id=post_id)
post_to_delete = PostSchema().dump(post_to_delete)
author_str = post_to_delete['author']
author_list = author_str.split()
author = Author.objects.filter(name=author_list[0], surname=author_list[1])[0]
author = Author.objects.get(id=author.id)
author.num_of_publications -= 1
author.save()
tag = Post(id=post_id)
tag.delete()
return post_to_delete
except DoesNotExist as error:
data = "За введеним ID наразі немає записів: " + str(error)
return data
except Val_error as error:
data = "Введений ID у невірному форматі: " + str(error)
return data
