Exemple #1
0
def get_posts():
    params = converts_keys(request.args.to_dict(), case='snake')
    set_filter_params(DEFAULT_POST_LIMIT, MAX_POST_LIMIT, params)
    cookies = request.cookies
    if 'token' in cookies:
        with connect(DSN) as connection:
            with connection.cursor(cursor_factory=RealDictCursor) as cursor:
                cursor.execute(Users.get_user_id(), cookies)
                record = cursor.fetchone()
                user_id = record['user_id']
    else:
        user_id = 0
    with connect(DSN) as connection:
        with connection.cursor(cursor_factory=RealDictCursor) as cursor:
            if 'search' in params:
                params['search'] = '%' + params['search'] + '%'
            cursor.execute(Posts.filter(**params), {
                'user_id': user_id,
                **params
            })
            posts = cursor.fetchall()
            cursor.execute(Posts.count(**params), params)
            record = cursor.fetchone()
    for post in posts:
        put_out_author(post)
    return jsonify(converts_keys({'posts': posts, **record}, case='camel'))
Exemple #2
0
	def get(self, format=None):
		post = Posts(id=self.id, slug=self.slug, type=self.type)
		postData = post.get()
		if postData is None:
			return {'code': 404, 'message': 'NOT FOUND'}
		postData['date'] = time.mktime(postData['date'].timetuple())*1000
		if format is None:
			postData['content'] = markdown.markdown(postData['content'], extensions = ['codehilite'])
		return {'code': 200, 'data': postData}
Exemple #3
0
	def get(self, ignore=None):
		post = Posts(type=self.type, date=self.date, tag=self.tag, author=self.author)
		posts = post.archives(page=self.page)
		if posts is None:
			return {'code': 404, 'message': 'NOT EXSITS'}
		posts['data'] = self.__formatListDate(posts['data'])
		if ignore is not None:
			for i, post in enumerate(posts['data']):
				posts['data'][i].pop(ignore)
		return {'code': 200, 'data': posts['data'], 'pager': posts['pager']}
Exemple #4
0
 def get(self, id=None):
     header = self.get_argument('header', default=None)
     content = self.get_argument('content', default=None)
     author = self.get_argument('author', default=None)
     categories = self.get_arguments('categories')
     post = Posts(header, content, author, id)
     try:
         Posts.update(post, categories)
     except:
         self.send_error(400)
Exemple #5
0
 def get(self):
     header = self.get_argument('header')
     content = self.get_argument('content')
     author = self.get_argument('author')
     categories = self.get_arguments('categories')
     if not categories:
         self.send_error(400)
     else:
         post = Posts(header, content, author)
         Posts.add(post, categories)
Exemple #6
0
	def save(self, data):
		self.__setPostDate(data)
		empty = self.__isEmpty(['title', 'tag', 'type', 'content'])
		if len(empty) > 0:
			return {'code': 403, 'empty': empty}
		post = Posts(id=self.id, title=self.title, content=self.content, tag=self.tag, type=self.type, author=self.author, slug=self.slug)
		if self.id is None:
			post.create()
		else:
			post.update()
		return {'code': 200}
Exemple #7
0
 def get(self, id=None):
     if id == None:
         result = Posts.get_all()
         posts = []
         for post in result:
             posts.append(post.toDict())
         self.write({'posts': posts})
     else:
         try:
             post = Posts.get(id)
             self.write(post.toDict())
         except:
             self.send_error(400)
Exemple #8
0
def delete_post(post_id):
    cookies = request.cookies
    if 'token' not in cookies:
        return jsonify(), 401
    with connect(DSN) as connection:
        with connection.cursor(cursor_factory=RealDictCursor) as cursor:
            cursor.execute(Users.get_user_id(), cookies)
            user_id = cursor.fetchone()['user_id']
            cursor.execute(Posts.get_author_id(), {'id': post_id})
            author_id = cursor.fetchone()['author_id']
    if user_id != author_id:
        return jsonify(), 401
    with connect(DSN) as connection:
        with connection.cursor(cursor_factory=RealDictCursor) as cursor:
            cursor.execute(Posts.delete(), {'id': post_id})
    return jsonify(), 205
Exemple #9
0
def post():
    form = PostForm()
    src = [{'filetype': 'None', 'path': 'None'}]
    privacy = request.form['privacy']
    if request.method == 'POST':
        if 'media' in request.files:
            media = request.files.getlist('media')
            process = upload(media, privacy=privacy, used_as='post')
            if process['result'] == 'done':
                path = process['path']
                type_ = process['filetype']
                postname = process['postname']
                src = [{'path': path, 'filetype': type_, 'filename': postname}]
            pass
        if form.validate_on_submit():
            new_post = Posts(post_content={
                'headline': form.headline.data,
                'body': form.body.data,
                'media': src
            },
                             privacy=privacy,
                             timestamp=getDate())
            db.session.add(new_post)
            db.session.commit()
            flash("Post successfull!", "success")
            return redirect(url_for('home'))
        return redirect(url_for("home"))
    abort(400)
Exemple #10
0
def upload_post():
	form = UploadPostForm()
	if form.validate_on_submit():
		title = form.title.data.strip(' ')
		content = form.content.data.strip(' ')
		image_name = form.image_name.data.strip(' ')
		
		old = Posts.query.filter_by(title=title).first()
		if old:
			flash('post already collected')
			return redirect(url_for('admin.upload_post'))

		post = Posts(title=title, content=content)
		post.add_tag(form.tags.data)
		post.image_name = image_name
		post.description = form.description.data
		post.author = current_user

		db.session.add(post)
		db.session.commit()

		flash('upload successful')
		return redirect(url_for('admin.upload_post'))

	return render_template('admin/upload_post.html',form=form)
Exemple #11
0
def update_post(post_id):
    payload = converts_keys(loads(request.data), case='snake')
    check_only_required_payload_props(payload, 'category', 'content')
    cookies = request.cookies
    if 'token' not in cookies:
        return jsonify(), 401
    with connect(DSN) as connection:
        with connection.cursor(cursor_factory=RealDictCursor) as cursor:
            cursor.execute(Users.get_user_id(), cookies)
            user_id = cursor.fetchone()['user_id']
            cursor.execute(Posts.get_author_id(), {'id': post_id})
            author_id = cursor.fetchone()['author_id']
    if user_id != author_id:
        return jsonify(), 401
    with connect(DSN) as connection:
        with connection.cursor(cursor_factory=RealDictCursor) as cursor:
            cursor.execute(Posts.update(), {'id': post_id, **payload})
            post = cursor.fetchone()
    return jsonify(converts_keys(post, case='camel'))
Exemple #12
0
def unlike():
    params = converts_keys(request.args.to_dict(), case='snake')
    cookies = request.cookies
    if 'token' not in cookies:
        return jsonify(), 401
    with connect(DSN) as connection:
        with connection.cursor(cursor_factory=RealDictCursor) as cursor:
            cursor.execute(Users.get_user_id(), cookies)
            record = cursor.fetchone()
            if 'post_id' in params:
                cursor.execute(Posts.unlike(), {**record, **params})
            elif 'comment_id' in params:
                cursor.execute(Comments.unlike(), {**record, **params})
            elif 'reply_id' in params:
                cursor.execute(Replies.unlike(), {**record, **params})
            else:
                jsonify(), 400
    return jsonify(), 205
Exemple #13
0
from database import Posts
from flask import Flask, render_template, request, url_for, redirect
import time

app = Flask(__name__) #Instantiated Flask Object
newpost = Posts()

@app.route("/")
@app.route("/home")
def home():
    return render_template('home01.html', posts = newpost.posts, comment = len(newpost.posts))

@app.route("/about")
def about():
    return render_template('about01.html', title = 'about')

@app.route("/post")
def post():
    return render_template('post.html')

@app.route("/create", methods = ["POST"])
def create_post():
    author = request.form['author']
    title = request.form['title']
    date_posted = time.strftime("%e %B, %Y", time.localtime())
    content = request.form['content']
    newpost.get_Dict(author, title, content, date_posted)
    newpost.StoreDatabase()
    return redirect(url_for('home'))
    
if __name__ == "__main__":
Exemple #14
0
 def get(self, id=None):
     try:
         Posts.delete(id)
     except:
         self.send_error(400)