def setUpClass(cls):
try:
cls.client = webdriver.Firefox()
except:
pass
if cls.client:
# create app
cls.app = create_app('testing')
cls.app_context = cls.app.app_context()
cls.app_context.push()
# create log
import logging
logger = logging.getLogger('werkzeug')
logger.setLevel(logging.ERROR)
# create database
db.create_all()
Role.init_roles()
User.generate_fake(count=10)
Post.generate_fake(count=10)
# add admin
admin_role = Role.query.filter_by(permissions=0xff).first()
admin = User(email='*****@*****.**', username='******',
password='******', role=admin_role, confirmed=True)
db.session.add(admin)
db.session.commit()
# run server in child thread
Thread(target=cls.app.run).start()
def get_more():
"""Handles requests for more post and submissions when a user presses "Show more" """
start = int(request.form.get("start"))
rendered_posts = []
template = get_template_attribute('partials/_post.html', "post_template")
posts = []
page = request.form.get("page")
if page == "home":
status = request.form.get("status")
if status == "open":
posts = Post.get_open_posts(start)
if status == "closed":
posts = Post.get_closed_posts(start)
if status == "archived":
posts = Post.get_archived_posts(start)
if page == "search":
query, difficulty, tag = parse_search_query(request.form.get("query"))
posts = Post.get_searched_posts(query, difficulty=difficulty, tag=tag, start=start)
if posts:
for post in posts:
post_html = template(page=page, post=post)
rendered_posts += [post_html]
return jsonify({
"success": True,
"posts": rendered_posts
})
else:
return jsonify({
"success": False
})
def setUpClass(cls):
try:
cls.client = webdriver.Firefox()
except:
pass
if cls.client:
cls.app = create_app('testing')
cls.app_context = cls.app_context()
cls.app_context.push()
import logging
logger = logging.getLogger('werkzeug')
logger.setLevel("ERROR")
db.create_all()
Role.insert_roles()
User.generate_fake(10)
Post.generate_fake(10)
admin_role = Role.query.filter_by(permissions=0xff).first()
admin = User(email='*****@*****.**',
username='******', password='******',
role=admin_role, confirmed=True)
db.session.add(admin)
db.session.commit()
threading.Thread(target=cls.app.run).start()
time.sleep(1)
def recreate_data():
"""Generate fake data for development and testing"""
print 'dropping existing tables...'
db.drop_all()
print 'creating tables...'
db.create_all()
print 'inserting roles...'
Role.insert_roles()
print 'creating admin user...'
u1 = User(username='******', email='*****@*****.**', password='******',
name='Ralph Wen', location='Hangzhou, China',
about_me='This is the creator of everything', confirmed=True)
db.session.add(u1)
print 'creating moderate user...'
u2 = User(username='******', email='*****@*****.**', password='******',
name='Yadong Wen', location='Hangzhou, China',
about_me='Yeah', confirmed=True)
db.session.add(u2)
db.session.commit()
print 'generating 50 normal users...'
User.generate_fake(50)
print 'generating 500 posts...'
Post.generate_fake(500)
print 'generating follows...'
User.generate_following()
print 'generating comments...'
Comment.generate_comments()
print '...done'
def setUpClass(cls): # 在这个类中的全部测试运行前执行
# 启动 Chrome
try:
cls.client = webdriver.Chrome() # 在类方法中，通过 cls 参数调用类的方法、属性
except:
pass
# 如果无法启动浏览器,则跳过这些测试
if cls.client:
# 创建程序
cls.app = create_app('testing')
cls.app_context = cls.app.app_context()
cls.app_context.push()
# 日志？？
import logging
logger = logging.getLogger('werkzeug') # 获取logger对象
logger.setLevel('ERROR') # 设置获取 ERROR 级别的日志
# 创建数据库，使用一些虚拟数据填充
db.create_all()
Role.insert_roles()
User.generate_fake(10)
Post.generate_fake(10)
# 添加管理员用户
admin_role = Role.query.filter_by(permissions=0xff).first()
admin = User(email='*****@*****.**', username='******', password='******', role=admin_role, confirmed=True)
db.session.add(admin)
db.session.commit()
# 在线程中启动 Flask 服务器
threading.Thread(target=cls.app.run).start() # 启用程序
def setUpClass(cls):
# start Firefox
try:
cls.client = webdriver.Firefox()
except:
pass
# skip these tests if the browser could not be started
if cls.client:
# create the application
cls.app = create_app('testing')
cls.app_context = cls.app.app_context()
cls.app_context.push()
# suppress logging to keep unittest output clean
import logging
logger = logging.getLogger('werkzeug')
logger.setLevel("ERROR")
# create the database and populate with some fake data
db.create_all()
Post.generate_fake()
# start the Flask server in a thread
threading.Thread(target=cls.app.run).start()
# give the server a second to ensure it is up
time.sleep(1)
def test_post_model_remove_ingredients(self):
post = Post('Title', 'Body', 1, difficulty=1)
ingredient = Ingredient("ingredient", post.id)
post.ingredients.append(ingredient)
self.assertEqual(post.ingredients.all(), [ingredient])
post.remove_ingredients()
self.assertEqual(post.ingredients.all(), [])
def rebuild():
if config == 'development':
with app.app_context():
db.drop_all()
db.create_all()
Role.insert_roles()
admin_me = User(email=app.config['FLASKR_ADMIN'],
username=app.config['MY_USERNAME'],
password=app.config['MY_PASSWORD'],
confirmed=True,
name=forgery_py.name.full_name(),
location=forgery_py.address.city(),
about_me=forgery_py.lorem_ipsum.sentences(10),
member_since=forgery_py.date.date(True,
min_delta=10))
db.session.add(admin_me)
ordinary_me = User(email=forgery_py.internet.email_address(),
username='******',
password='******',
confirmed=True,
name=forgery_py.name.full_name(),
location=forgery_py.address.city(),
about_me=forgery_py.lorem_ipsum.sentences(10),
member_since=forgery_py.date.date(True,
min_delta=10))
db.session.add(ordinary_me)
db.session.commit()
User.generate_fake(30)
Post.generate_fake(500)
Follow.generate_fake(500)
Comment.generate_fake(500)
else:
print('Permission denied.')
def setUpClass(cls):
#launch Firefox
try:
cls.client = webdriver.Chrome()
except:
pass
if cls.client:
cls.app = create_app('testing')
cls.app_context = cls.app.app_context()
cls.app_context.push()
import logging
logger = logging.getLogger('werkzeug')
logger.setLevel('ERROR')
# create database, and fill it up with some faked data
db.create_all()
Role.insert_roles()
User.generate_fake(10)
Post.generate_fake(10)
# add administrater
admin_role = Role.query.filter_by(permissions=0xff).first()
admin = User(email='*****@*****.**',
username='******', password='******',
role=admin_role, confirmed=True)
db.session.add(admin)
db.session.commit()
# launch Flask server in a thread
threading.Thread(target=cls.app.run).start()
# give the server a second to ensure it is up
time.sleep(1)
def put(self, id):
"""
Input: id
Method: PUT
Return: 更新文章信息
"""
args = self.reqparse.parse_args()
post = Post.objects(id=id)
if len(post) == 0:
abort(404)
post = post[0]
title = args.get('title')
body = args.get('body')
mark = args.get('mark')
post.body = body
if title != post.title:
if len(Post.objects(title=title)) > 0:
# title same
abort(400)
post.title = title
if mark != post.mark:
if len(Post.objects(mark=mark)) > 0:
# mark same
abort(400)
post.mark = mark
post.save()
# For a PUT request: HTTP 200 or HTTP 204 should imply "resource updated successfully".
print(post.get_dict())
return post.get_dict(), 200
def setUpClass(cls):
try:
cls.client = webdriver.Firefox()
except:
pass
if cls.client:
# 创建程序
cls.app = create_app('test')
cls.app_context = cls.app.app_context()
cls.app_context.push()
# 禁止日志,保持输出简洁
import logging
logger = logging.getLogger('werkzeug')
logger.setLevel("ERROR")
# 创建数据库,并使用一些虚拟数据填充
db.create_all()
Role.insert_role()
User.generate_fake(10)
Post.generate_fake(10)
# 添加管理员
admin_role = Role.query.filter_by(permissions=0xff).first()
admin = User(email='*****@*****.**',
username='******', password='******',
role=admin_role, confirmed=True)
db.session.add(admin)
db.session.commit()
# 在一个线程中启动 Flask 服务器
threading.Thread(target=cls.app.run).start()
def setUpClass(cls):
# start Firefox
try:
cls.client = webdriver.Firefox()
except:
pass
# skip these tests if the browser could not be started
if cls.client:
# create the application
cls.app = create_app('testing')
cls.app_context = cls.app.app_context
cls.app_context.push()
# suppress logging to keep unittest output clean
import logging
logger = logging.getLogger('werkzeug')
logger.setLevel('ERROR')
# create the database and populate with some fake data
db.create_all()
Role.insert_roles()
User.generate_fake(10)
Post.generate_fake(10)
# add an administrator user
admin_role = Role.query.filter_by(permissions=0xff).first()
admin = User(email='*****@*****.**',
username='******', password='******',
role=admin_role, confirmed=True)
db.session.add(admin)
db.session.commit()
# start the Flask server in a thread
threading.Thread(target=cls.app.run).start()
def post_edit(post_id):
if request.method == 'GET':
try:
post = Post.get(Post.post_id == post_id) # todo: get not deleted
except Post.DoesNotExist:
abort(404)
form = PostForm(obj=post)
all_categories = Category.select()
template = env.get_template('post/edit.html')
return template.render(
item=post,
form=form,
categories=all_categories,
)
elif request.method == 'POST':
post = Post.get(Post.post_id == post_id)
post.category = post_get('category-id')
post.post_text = post_get('text')
post.slug = post_get('slug')
post.title = post_get('title')
post.draft = bool(int(post_get('draft'))) # zero int is False
post.language = post_get('language')
post.show_on_index = bool(post_get('show-on-index'))
post.date_updated = datetime.now()
new_tags = post_get('tags')
old_tags = Tag.select().join(Tag_to_Post)\
.where(Tag_to_Post.post_id == post_id)
remove_tags(old_tags, new_tags, post_id)
add_new_tags(new_tags, post_id)
post.save()
app.flash('Article updated')
redirect('/post/' + str(post_id))
def test_get_post_by_tag_name(self):
file_object1 = werkzeug.datastructures.FileStorage(filename="fileupload1.JPG")
file_object2 = werkzeug.datastructures.FileStorage(filename="fileupload2.JPG")
p = Post.create(author_id=1, description="test", file_name=None, tag_list="food,fashion", choice_data=[("text_choice1", file_object1), ("text_choice2", file_object2)])
self.assertIn(p, Post.get_posts_by_tag("food"))
self.assertIn(p, Post.get_posts_by_tag("fashion"))
self.assertNotIn(p, Post.get_posts_by_tag("apple"))
def test_06_rename_category(self):
"""测试分类改名"""
cate1 = Category(name='cate1')
db.session.add(cate1)
db.session.commit()
cate2 = Category(name='cate2')
cate2.parent = cate1
db.session.add(cate2)
db.session.commit()
cate3 = Category(name='cate3')
cate3.parent = cate2
db.session.add(cate3)
db.session.commit()
p = Post()
Post.publish(post=p,
title='post',
content='post',
category=cate2)
cate1.name = 'cate11'
cate2.name = 'cate222'
self.assertTrue(cate2 in cate1.children.all() and
cate2.link == 'cate11/cate222' and
cate3 in cate2.children.all() and
cate3.link == 'cate11/cate222/cate3' and
cate3.level == 2 and
cate3.parent == cate2 and
cate2.posts_count == 1 and
cate1.posts_count == 1 and
cate3.posts_count == 0)
def post(self, topic_id):
title = self.get_argument('title', None)
keywords = self.get_argument('keywords', None)
content = self.get_argument('content', '')
keep_silent = int(self.get_argument('keep_silent', 0))
is_draft = int(self.get_argument('is_draft', 0))
if not all([title, keywords]):
raise exceptions.EmptyFields()
else:
can_post = yield gen.maybe_future(Topic.can_post(topic_id))
if not can_post:
raise exceptions.TopicIsNotAccepted
exists = yield gen.maybe_future(Post.get_by_title(title))
if exists:
raise exceptions.PostTitleAlreadyExists()
else:
username = self.current_user
yield gen.maybe_future(
Post.create(username, topic_id,
title, keywords, content,
keep_silent=keep_silent, is_draft=is_draft))
# Update gold.
update_gold.apply_async(('new_post', username))
def setUpClass(cls):
chromedriver_dir = os.path.abspath('./driver/chromedriver.exe')
cls.client = webdriver.Chrome(executable_path=chromedriver_dir)
if cls.client:
cls.app = create_app('testing')
cls.app_context = cls.app.app_context()
cls.app_context.push()
import logging
logger = logging.getLogger('werkzeug')
logger.setLevel("ERROR")
db.create_all()
Role.insert_roles()
User.generate_fake(10)
Post.generate_fake(10)
admin_role = Role.query.filter_by(permissions=0xff).first()
admin = User(email='*****@*****.**',
username='******',
password='******',
role=admin_role,
confirmed=True)
db.session.add(admin)
db.session.commit()
threading.Thread(target=cls.app.run).start()
def add_post():
user = User.objects(name='admin').first()
post = Post(title="Hello",
content="Hello world",
author=user,
tags=['python', 'flask'])
post.save()
def delete(self, id):
post = Post.get_by_id(id)
if post is None:
return render_view(url_for('PostsView:index'),
status=False,
redirect=True,
message=_('POST_NOT_FOUND'))
if not post.can_edit():
abort(401)
try:
title = post.title
Post.delete(post.id)
Feed.clear_feed_cache()
ret = request.values.get('return')
flash(_('POST_DELETE_SUCESS', title=title))
if ret:
return render_view(ret, redirect=True)
except Exception as e:
flash(_('ERROR_POST_DELETE_FAILED', error=e), 'error')
return render_view(url_for('PostsView:index'),
redirect=True)
def test_post_model_is_visible(self):
date = datetime.utcnow() - timedelta(1)
post = Post('Title', 'Body', 1, publish_time=date, difficulty=2)
self.assertTrue(post.is_visible())
date = datetime.utcnow() + timedelta(1)
post = Post('Title', 'Body', 1, publish_time=date, difficulty=2)
self.assertFalse(post.is_visible())
def createPost(author=None, title=None, description=None, link=None, \
date_created = None, score = 0, num_comments = 0, votes = None,\
access = None, tags = None):
"""
创建一个新的Post
id = db.Column(db.Integer, primary_key=True)
author_id = db.Column(db.Integer,
db.ForeignKey(User.id, ondelete='CASCADE'),
nullable=False)
title = db.Column(db.Unicode(200))
description = db.Column(db.String)
link = db.Column(db.String(250))
date_created = db.Column(db.DateTime, default=datetime.utcnow)
score = db.Column(db.Integer, default=1)
num_comments = db.Column(db.Integer, default=0)
votes = db.Column(DenormalizedText)
access = db.Column(db.Integer, default=PUBLIC)
_tags = db.Column("tags", db.String)
author = db.relation(User, innerjoin=True, lazy="joined")
"""
post = Post(author_id=author.id,
title=title,
description=description,
link=link,
date_created = date_created,
score = score,
num_comments = num_comments,
votes = votes,
access = access,
tags =tags)
post.save()
return post
def setUpClass(cls):
#启动Firefox
try:
cls.client=webdriver.FireFox()
except:
pass
#如果无法启动浏览器，则跳过这些测试
if cls.client:
#创建程序
cls.app=create_app('testing')
cls.app_context=cls.app.app_context()
cls.app_context.push()
#禁止日志，保持输出整洁
import logging
logger=logging.getlogger('werkzeug')
logger.setLevel("ERROR")
#创建数据库，并使用一些虚拟数据填充
db.create_all()
Role.insert_roles()
User.generate_fake(10)
Post.generate_fake(10)
#添加管理员
admin_role=Role.query.filter_by(permission=0xff).first()
admin=User(email='*****@*****.**',username='******', password='******',role=admin_role)
db.session.add(admin)
db.session.commit()
#在一个线程中启动FLask服务器
threading.Thread(target=cls.app.run).start()
def test_02_save_new_post(self):
"""新建一篇文章, 不发布而保存为草稿"""
t = Tag.query.filter_by(_name='tag').first()
a = Tag.query.filter_by(_name='gat').first()
c = Category.query.filter_by(_name='cate').first()
p = Post()
Post.save(post=p,
title='po st',
content='post_abstract<!--more-->post_content',
public=False,
commendable=False,
tags='tag, gat',
category=c)
p = Post.query.filter_by(_title='po st').first()
self.assertTrue(p.type == 'draft' and
p.date and
not p.publish_date and
p.category == c and
p.tags == ['tag', 'gat'] and
p.draft is None and
t.posts_count == 0 and
a.posts_count == 0 and
c.posts_count == 0)
def writing():
if request.method == 'POST':
title = request.form['title']
summary = request.form['summary']
body = request.form['content']
# tag = request.form['tag']
if 'theme-img' in request.files:
image = request.files['theme-img']
image_name = image.filename
new_image_name = unique_filename(image_name)
image_path = os.path.join(app.config['UPLOAD_FOLDER'], new_image_name)
image.save(image_path)
theme_img = url_for('uploaded_file', filename=new_image_name)
thumbnail_img_name = create_thumbnail_and_save(image_path, image_name, app.config['MAX_POST_IMG_WIDTH'])
thumbnail_img = url_for('uploaded_file', filename=thumbnail_img_name)
else:
theme_img = app.config['DEFAULT_POST_IMG']
thumbnail_img = app.config['DEFAULT_POST_THUMB_IMG']
# tag = Tag(name=tag, creator_id=current_user.id)
post = Post(title=title, theme_img=theme_img, thumbnail_img=thumbnail_img,
summary=summary, body=body, user_id=current_user.id)
# post.tags.append(tag)
post.save()
return redirect(url_for('blog.article', post_id=post.id))
return render_template('profile/writing.html')
def setUp( self ):
self.app = create_app('test')
self.app_context = self.app.app_context()
self.app_context.push()
db.create_all()
Role.insert_roles()
User.generate_fake(count=5)
Post.generate_fake( count=5)
def test_03_post_link(self):
"""测试文章link替代文章标题空格为下划线"""
p = Post()
Post.publish(post=p,
title='po st',
content='post'
)
self.assertTrue(p.link == 'po_st')
def test_post_model_are_submissions_open(self):
date = datetime.today() - timedelta(1)
post = Post('Title', 'Body', 1, publish_time=date, difficulty=3)
self.assertTrue(post.are_submissions_open())
date = datetime.today() - timedelta(8)
post = Post('Title', 'Body', 1, publish_time=date, difficulty=3)
self.assertFalse(post.are_submissions_open())
def add_post():
user = User.objects(name="****").first()
post = Post(title="Hello",
content="Hello new world",
status=1,
author=user,
tags=['python','flask'])
post.save()
def curl_post():
try:
content = request.json.get("content")
title = request.json.get("title")
post = Post(user=g.user, title=title, content=content, pub_date=datetime.now())
post.save()
return jsonify({"data": "Hello, %s!" % g.user.username})
except:
return jsonify({"data": "Something Went Wrong."})
def test_04_post_abstract(self):
"""测试文章摘要"""
p = Post()
Post.publish(post=p,
title='po st',
content='post_abstract<!--more-->post_content'
)
self.assertTrue(p.abstract == 'post_abstract')
class UserTestCase(TestCase):
def create_app(self):
"""Creates an app object for testing purposes."""
self.app = create_app('TESTING')
self.app_context = self.app.app_context()
self.app_context.push()
return self.app
def setUp(self):
"""Sets up a test database."""
self.app.config['TESTING'] = True
self.app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///unittest.db'
self.app = self.app.test_client()
db.create_all()
def tearDown(self):
"""Removes all objects from the database and the app_context."""
db.session.remove()
db.drop_all()
self.app_context.pop()
def test_register_user(self):
"""Tests whether users can be inserted into the database."""
self.user = User(username="******", email="*****@*****.**", id=1)
self.user.set_password("password")
db.session.add(self.user)
db.session.commit()
def test_can_fetch_user(self):
"""Tests whether users can be fetched from the database."""
self.user = User(username="******", email="*****@*****.**", id=1)
self.user.set_password("password")
db.session.add(self.user)
db.session.commit()
self.query = User.query.filter_by(username="******").first()
self.query = User.query.filter_by(email="*****@*****.**").first()
self.query = User.query.filter_by(id=1).first()
def test_password_is_equal(self):
"""Tests whether check_password() works."""
self.user = User(username="******", email="*****@*****.**", id=1)
self.user.set_password("password")
self.assertTrue(self.user.check_password('password'))
def test_username(self):
"""Makes sure the username in the database is the same as inputted."""
self.user = User(username="******", email="*****@*****.**", id=1)
self.assertEqual("John", self.user.username)
def test_voting(self):
"""Tests whether a user can up or downvote."""
self.post = Post(title="Title", text="Text")
self.user = User(username="******", email="*****@*****.**", id=1)
self.user.upvoted_on.append(self.post)
self.post = Post(title="Rick", text="Jaime")
self.user.downvoted_on.append(self.post)
for i in self.user.upvoted_on:
self.assertEqual(i.title, "Title")
for i in self.user.downvoted_on:
self.assertEqual(i.title, "Rick")
def test_giving_importance(self):
"""Tests whether a user can give importance."""
self.post = Post(title="Title", text="Text")
self.user = User(username="******", email="*****@*****.**", id=1)
self.user.given_importance_to.append(self.post)
for i in self.user.given_importance_to:
self.assertEqual(i.title, "Title")
def test_sum_post_scores(self):
"""Tests to see whether the program can iterate through a users
post's score."""
self.user = User(username="******", email="*****@*****.**", id=1)
self.user.importance_debt = 0
db.session.add(self.user)
db.session.commit()
self.post = Post(title="Title", text="Text", user_id=self.user.id)
self.post.upvotes = 1
self.post.downvotes = 0
self.post.score = self.post.get_score()
db.session.add(self.post)
db.session.commit()
self.assertEqual(self.user.sum_post_scores(), 1)
import json
from app import DAO
from app.models import User, Post
# user = User(username='******', email='*****@*****.**')
# user.set_password('admin@123')
# user2 = User(username='******', email='*****@*****.**')
# user2.set_password('marco@123')
user = DAO.buscar_por_criterio_bool(User, User.username == 'admin')
# print(user)
user2 = DAO.buscar_por_criterio(User, username='******')
post2 = Post(body='Minha bola! hahaha')
# user2.posts.append(post)
# DAO.transacao(user2)
# print(user2)
# user3 = DAO.buscar_por_criterio_404(User, username='******')
# print(user3)
# user4 = DAO.buscar_todos(User, User.username, User.email)
# for u in user4:
# print(20*'-')
# print(u)
# [print(p) for p in u.posts]
# DAO.deletar(user2)
# user5 = DAO.buscar_todos_por_join(User, Post, User.username)
# print(user5)
# posts = DAO.buscar_todos(Post)
# [DAO.deletar(p) if 'Hi' in p.body else print('Registro não existe') for p in posts]
def post(post_id):
post = Post().query.get(post_id)
return render_template('posts/post.html', post=post)
def delete(post_id):
post = Post().query.get(post_id)
db.session.delete(post)
db.session.commit()
flash('"{}" was successfully deleted!'.format(post.title), 'success')
return redirect(url_for('main.index'))
def index():
posts = Post.get_all()
return render_template("public/index.html", posts=posts)
def show_error():
res = 1 / 0
posts = Post.get_all()
return render_template("public/index.html", posts=posts)
def preview_post():
return render_template('/main/post.html',
categories=Category().fetch_categories(),
new=Post().last_submission())
def test_empty_post(self):
self.assertRaises(
Post(title='test empty input',
body='',
user_name='Melvin the Mute',
timestamp=datetime.utcnow()))
def test_comments(self):
# add two users
r = Role.query.filter_by(name="User").first()
self.assertIsNotNone(r)
u1 = User(
email="*****@*****.**",
username="******",
password="******",
confirmed=True,
role=r,
)
u2 = User(
email="*****@*****.**",
username="******",
password="******",
confirmed=True,
role=r,
)
db.session.add_all([u1, u2])
db.session.commit()
# add a post
post = Post(body="body of the post", author=u1)
db.session.add(post)
db.session.commit()
# write a comment
response = self.client.post(
"/api/v1/posts/{}/comments/".format(post.id),
headers=self.get_api_headers("*****@*****.**", "dog"),
data=json.dumps({"body": "Good [post](http://example.com)!"}),
)
self.assertEqual(response.status_code, 201)
json_response = json.loads(response.get_data(as_text=True))
url = response.headers.get("Location")
self.assertIsNotNone(url)
self.assertEqual(json_response["body"],
"Good [post](http://example.com)!")
self.assertEqual(re.sub("<.*?>", "", json_response["body_html"]),
"Good post!")
# get the new comment
response = self.client.get(url,
headers=self.get_api_headers(
"*****@*****.**", "cat"))
self.assertEqual(response.status_code, 200)
json_response = json.loads(response.get_data(as_text=True))
self.assertEqual("http://localhost" + json_response["url"], url)
self.assertEqual(json_response["body"],
"Good [post](http://example.com)!")
# add another comment
comment = Comment(body="Thank you!", author=u1, post=post)
db.session.add(comment)
db.session.commit()
# get the two comments from the post
response = self.client.get(
"/api/v1/posts/{}/comments/".format(post.id),
headers=self.get_api_headers("*****@*****.**", "dog"),
)
self.assertEqual(response.status_code, 200)
json_response = json.loads(response.get_data(as_text=True))
self.assertIsNotNone(json_response.get("comments"))
self.assertEqual(json_response.get("count", 0), 2)
# get all the comments
response = self.client.get(
"/api/v1/posts/{}/comments/".format(post.id),
headers=self.get_api_headers("*****@*****.**", "dog"),
)
self.assertEqual(response.status_code, 200)
json_response = json.loads(response.get_data(as_text=True))
self.assertIsNotNone(json_response.get("comments"))
self.assertEqual(json_response.get("count", 0), 2)
def predict():
data_file = 'reviews_final.csv'
data = pd.read_csv(data_file)
stopwords_eng = stopwords.words('english')
stopwords_eng2 = stopwords_eng
stopwords_eng2 = [x.capitalize() for x in stopwords_eng2]
stopwords_final = stopwords_eng + stopwords_eng2
class ApplyRegex(BaseEstimator, TransformerMixin):
def __init__(self,
break_line=True,
carriage_return=True,
numbers=True,
number_replacing='',
special_char=True,
additional_spaces=True):
self.break_line = break_line
self.carriage_return = carriage_return
self.numbers = numbers
self.number_replacing = number_replacing
self.special_char = special_char
self.additional_spaces = additional_spaces
def fit(self, X, y=None):
return self
def transform(self, X, y=None):
X_transformed = []
for c in X:
if self.break_line:
c = re.sub('\n', ' ', c)
if self.carriage_return:
c = re.sub('\r', ' ', c)
if self.numbers:
c = re.sub(r'\d+(?:\.\d*(?:[eE]\d+))?',
self.number_replacing, c)
if self.special_char:
c = re.sub(r'R\$', ' ', c)
c = re.sub(r'\W', ' ', c)
if self.additional_spaces:
c = re.sub(r'\s+', ' ', c)
X_transformed.append(c)
return X_transformed
class StopWordsRemoval(BaseEstimator, TransformerMixin):
def fit(self, X, y=None):
return self
def stopword_removal(self):
y = []
review_no_stopword = []
for idx, review in enumerate(self):
try:
y = ''
for word in review.split():
if word not in stopwords_final:
y += word + ' '
review_no_stopword.append(y)
except:
print(idx)
return review_no_stopword
def transform(self, X, y=None):
X_transformed = StopWordsRemoval.stopword_removal(X)
return X_transformed
class TextLemmatization(BaseEstimator, TransformerMixin):
def fit(self, X, y=None):
return self
def lemmatize_text(text):
return ' '.join(
lemmatizer.lemmatize(w, pos="v")
for w in w_tokenizer.tokenize(text))
def transform(self, X, y=None):
X_transformed = list(
map(lambda c: TextLemmatization.lemmatize_text(c), X))
return X_transformed
preprocess_pipeline = Pipeline([
('regex_cleaner', ApplyRegex()),
('stopwords_remover', StopWordsRemoval()),
('lemmatization', TextLemmatization()),
])
X = data['reviews.text']
y = data['reviews.rating'].values
y = y.astype(int)
X_preprocessed = preprocess_pipeline.fit_transform(X)
reviews_vector = list(map(lambda c: nltk.word_tokenize(c), X_preprocessed))
vectorizer = CountVectorizer(max_features=300)
X_transformed = vectorizer.fit_transform(X_preprocessed).toarray()
review_txt = request.form.get('review')
review = request.form.values()
preprocessed_review = preprocess_pipeline.fit_transform(review)
final_review = vectorizer.transform(preprocessed_review).toarray()
prediction = model.predict(final_review)
# Sentiment Score Predictor
# text_preprocessed = preprocess_pipeline.fit_transform([review_txt])
# text_transformed = vectorizer.transform(text_preprocessed).toarray()
# review_proba = model.predict_proba(text_transformed)
# sentiment_score = round(review_proba[0,2]*100,2)
# sentiment_score = sentiment_score.item()
form = PostForm()
if form.validate_on_submit():
text_preprocessed = preprocess_pipeline.fit_transform([form.post.data])
text_transformed = vectorizer.transform(text_preprocessed).toarray()
review_proba = model.predict_proba(text_transformed)
sentiment_score = round(review_proba[0, 2] * 100, 2)
sentiment_score = sentiment_score.item()
post = Post(body=form.post.data,
ecommerce_title=ecommerce_title,
author=current_user,
sentiment=sentiment_score)
db.session.add(post)
db.session.commit()
return redirect(url_for('product', title=ecommerce_title))
page = request.args.get('page', 1, type=int)
reviews = product.reviews.order_by(Post.timestamp.desc()).paginate(
page, app.config['POSTS_PER_PAGE'], False)
next_url = url_for('product', title=ecommerce_title, page=reviews.next_num) \
if reviews.has_next else None
prev_url = url_for('product', title=ecommerce_title, page=reviews.prev_num) \
if reviews.has_prev else None
return render_template('product.html',
prediction_text='Sentiment Score : ',
prediction_score='{}%'.format(sentiment_score),
review_text='Your review: {}'.format(review_txt),
reviews=reviews.items)
def setUp(self):
self.user_Farzana = User(
username="******", password="******", email="*****@*****.**")
self.new_post = Post(
title="bloger", body="blogging website", user_id=self.user_Farzana.id)
def test_comments(self):
# add two users
r = Role.query.filter_by(name='User').first()
self.assertIsNotNone(r)
u1 = User(email='*****@*****.**',
username='******',
password='******',
confirmed=True,
role=r)
u2 = User(email='*****@*****.**',
username='******',
password='******',
confirmed=True,
role=r)
db.session.add_all([u1, u2])
db.session.commit()
# add a post
post = Post(body='body of the post', author=u1)
db.session.add(post)
db.session.commit()
# write a comment
response = self.client.post(
'/api/v1/posts/{}/comments/'.format(post.id),
headers=self.get_api_headers('*****@*****.**', 'dog'),
data=json.dumps({'body': 'Good [post](http://example.com)!'}))
self.assertEqual(response.status_code, 201)
json_response = json.loads(response.get_data(as_text=True))
url = response.headers.get('Location')
self.assertIsNotNone(url)
self.assertEqual(json_response['body'],
'Good [post](http://example.com)!')
self.assertEqual(re.sub('<.*?>', '', json_response['body_html']),
'Good post!')
# get the new comment
response = self.client.get(url,
headers=self.get_api_headers(
'*****@*****.**', 'cat'))
self.assertEqual(response.status_code, 200)
json_response = json.loads(response.get_data(as_text=True))
self.assertEqual('http://localhost' + json_response['url'], url)
self.assertEqual(json_response['body'],
'Good [post](http://example.com)!')
# add another comment
comment = Comment(body='Thank you!', author=u1, post=post)
db.session.add(comment)
db.session.commit()
# get the two comments from the post
response = self.client.get(
'/api/v1/posts/{}/comments/'.format(post.id),
headers=self.get_api_headers('*****@*****.**', 'dog'))
self.assertEqual(response.status_code, 200)
json_response = json.loads(response.get_data(as_text=True))
self.assertIsNotNone(json_response.get('comments'))
self.assertEqual(json_response.get('count', 0), 2)
# get all the comments
response = self.client.get(
'/api/v1/posts/{}/comments/'.format(post.id),
headers=self.get_api_headers('*****@*****.**', 'dog'))
self.assertEqual(response.status_code, 200)
json_response = json.loads(response.get_data(as_text=True))
self.assertIsNotNone(json_response.get('comments'))
self.assertEqual(json_response.get('count', 0), 2)
def publish_post(hash_id):
post = Post.get_or_404(hash_id)
post.action_publish()
db.session.commit()
return jsonify(True)
def test_comments(self):
r = Role.query.filter_by(name='User').first()
self.assertIsNotNone(r)
u1 = User(email='*****@*****.**',
username='******',
password='******',
confirmed=True,
role=r)
u2 = User(email='*****@*****.**',
username='******',
password='******',
confirmed=True,
role=r)
db.session.add_all([u1, u2])
db.session.commit()
# add a post
post = Post(body='body of the post', author=u1)
db.session.add(post)
db.session.commit()
# write a comment
response = self.client.post(
url_for('api.new_post_comment', id=post.id),
headers=self.get_api_headers('*****@*****.**', 'dog'),
data=json.dumps({'body': 'Good [post[(http://example.com)!'}))
print(response.status_code)
self.assertTrue(response.status_code == 201)
json_response = json.loads(response.data.decode('utf-8'))
url = response.headers.get('Location')
self.assertIsNotNone(url)
self.assertTrue(
json_response['body'] == 'Good [post](http://example.com)!')
self.assertTrue(
re.sub('<.*?', '', json_response['body_html']) == 'Good post!')
# get the new comment
response = self.client.get(url,
headers=self.get_api_headers(
'*****@*****.**', 'cat'))
self.assertTrue(response.status_code == 200)
json_response = json.loads(response.data.decode('utf-8'))
self.assertTrue(json_response['url' == url])
self.assertTrue(
json_response['body'] == 'Good [post](http://example.com)!')
# add another comment
comment = Comment(body='Thank you!', author=u1, post=post)
db.session.add(comment)
db.session.commit()
# get the two comments from the post
response = self.client.get(url_for('api.get_post_comments',
id=post.id),
headers=self.get_api_headers(
'*****@*****.**', 'dog'))
self.assertTrue(response.status_code == 200)
json_response = json.loads(response.data.decode('utf-8'))
self.assertIsNotNone(json_response.get('comments'))
self.assertTrue(json_response.get('count', 0) == 2)
#get all the comments
response = self.client.get(url_for('api.get_comments', id=post.id),
headers=self.get_api_headers(
'*****@*****.**', 'dog'))
self.assertTrue(response.status_code == 200)
json_response = json.loads(response.data.decode('utf-8'))
self.assertIsNotNone(json_response.get('comments'))
self.assertTrue(json_response.get('count', 0) == 2)
def new_post(title: str, body: str) -> Post:
post = Post(title, body)
db.session.add(post)
db.session.commit()
return post
def post(id):
try:
post = Post.objects(id=id).get()
return render_template('post.html', title=post.title, post=post)
except:
abort(404)
def posts():
return render_template('/admin/posts.html',
message=get_flashed_messages(),
recent=Post().all_posts())
#!flask/bin/python
from app.models import User, Post
from app import db
import datetime
u = User.query.get(1)
p = Post(body='If I were a man', timestamp=datetime.datetime.utcnow (), \
author=u)
db.session.add(p)
p = Post(body='and you a dog', timestamp=datetime.datetime.utcnow (), \
author=u)
db.session.add(p)
p = Post(body='I\'d throw a stiick foor yoou', \
timestamp=datetime.datetime.utcnow (), author=u)
db.session.add(p)
db.session.commit()
def show_post(slug):
post = Post.get_by_slug(slug)
if post is None:
abort(404)
return render_template("public/post_view.html", post=post)
def test_comments(self):
#添加两名用户
r = Role.query.filter_by(name='User').first()
self.assertIsNotNone(r)
u1 = User.query.filter_by(email='*****@*****.**').first()
u2 = User.query.filter_by(email='*****@*****.**').first()
db.session.add_all([u1, u2])
db.session.commit()
#添加一篇博客
post = Post(body='body of the post', author=u1)
db.session.add(post)
db.session.commit()
#添加评论
response = self.client.post(
url_for('api.get_posts_comments', id=post.id),
headers=self.get_api_headers('*****@*****.**', 'dog'),
data=json.dumps({'body': 'Good[post](http://example.com)!'}))
self.assertTrue(response.status_code == 201)
url = response.headers.get('Location') #这里是从何处获取的Location
self.assertIsNotNone(url)
json_response = json.loads(response.data.decode('utf-8'))
self.assertTrue(
json_response['body'] == 'Good[post](http://example.com)!')
self.assertTrue(
re.sub('<.*?>', '', json_response['body_html']) ==
'Good post!') #这个正则表达式是什么意思？？？？？？
#获取评论
response = self.client.get(
url, #此处的url应该是前面获取的url,Location的那个
headers=self.get_api_headers('*****@*****.**', password='******'))
self.assertTrue(response.status_code == 200)
json_response = json.loads(response.data.decode('utf-8'))
self.assertTrue(json_response['url'] == url)
self.assertTrue(
json_response['body'] == 'Good[post](http://example.com)!')
#添加其他评论
comment = Comment(body='Thank you!', author=u1, post=post)
db.session.add(comment)
db.session.commit()
#从博客中获取两条评论
response = self.client.get(url_for('get_posts_comments', id=post.id),
headers=self.get_api_headers(
'*****@*****.**', password='******'))
self.assertTrue(response.status_code == 200)
json_response = json.loads(response.data.decode('utf-8'))
self.assertIsNotNone(json_response.get('posts'))
self.assertTrue(json_response.get(
'count', 0) == 2) #获取两条评论所以数字为2???????? 数字2是什么意思, 数字0是什么意思？？
#获取所有评论
response = self.client.get(url_for('get_comments'),
headers=self.get_api_headers(
'*****@*****.**', password='******'))
self.assertTrue(response.status_code == 200)
json_response = json.loads(response.data.decode('utf-8'))
self.assertIsNotNone(json_response.get('posts'))
self.assertTrue(json_response.get('count', 0) == 2)
def setUp(self):
self.new_user = User(username='******', email='*****@*****.**', password='******')
self.new_post = Post()
self.new_comment = Comment()
def generate_post(func_author):
return Post(title=lorem_ipsum.title(),
body=lorem_ipsum.paragraphs(),
created=date.date(),
author=func_author())
def testPost(self):
post = Post(title="My Title", description="Blurb", wiki="Post Body")
self.assertEqual(post.title, "My Title")
self.assertEqual(post.description, "Blurb")
self.assertEqual(post.wiki, "Post Body")
def draft_post(hash_id):
post = Post.get_or_404(hash_id)
post.action_draft()
db.session.commit()
return jsonify(True)
async def mutate(self, info: ResolveInfo, theme: str, description: str,
section_id: int) -> (lambda: CreatePost):
app = info.context['request'].app
async with app['db'].acquire() as conn:
post = Post(theme, description, section_id)
return CreatePost(ok=await post.save(conn))
def post():
post = Post(author=current_user, body=request.values.get('post'))
db.session.add(post)
db.session.commit()
return redirect(url_for('index'))
def delete_post(hash_id):
post = Post.get_or_404(hash_id)
Post.query.filter(Post.id == post.id).delete()
db.session.commit()
return jsonify(True)
def test_follow_posts(self):
u1 = User(nickname='john', email='*****@*****.**', social_id='john')
u2 = User(nickname='susan',
email='*****@*****.**',
social_id='susan')
u3 = User(nickname='mary', email='*****@*****.**', social_id='mary')
u4 = User(nickname='david',
email='*****@*****.**',
social_id='david')
db.session.add(u1)
db.session.add(u2)
db.session.add(u3)
db.session.add(u4)
utcnow = datetime.utcnow()
p1 = Post(body="post from john",
author=u1,
timestamp=utcnow + timedelta(seconds=1))
p2 = Post(body="post from susan",
author=u2,
timestamp=utcnow + timedelta(seconds=2))
p3 = Post(body="post from mary",
author=u3,
timestamp=utcnow + timedelta(seconds=3))
p4 = Post(body="post from david",
author=u4,
timestamp=utcnow + timedelta(seconds=4))
db.session.add(p1)
db.session.add(p2)
db.session.add(p3)
db.session.add(p4)
try:
db.session.commit()
except:
db.session.rollback()
raise
u1.follow(u1) # john follows himself
u1.follow(u2) # john follows susan
u1.follow(u4) # john follows david
u2.follow(u2) # susan follows herself
u2.follow(u3) # susan follows mary
u3.follow(u3) # mary follows herself
u3.follow(u4) # mary follows david
u4.follow(u4) # david follows himself
db.session.add(u1)
db.session.add(u2)
db.session.add(u3)
db.session.add(u4)
try:
db.session.commit()
except:
db.session.rollback()
raise
f1 = u1.followed_posts().all()
f2 = u2.followed_posts().all()
f3 = u3.followed_posts().all()
f4 = u4.followed_posts().all()
assert len(f1) == 3
assert len(f2) == 2
assert len(f3) == 2
assert len(f4) == 1
assert f1 == [p4, p2, p1]
assert f2 == [p3, p2]
assert f3 == [p4, p3]
assert f4 == [p4]
def get_post_comments():
hash_id = request.args.get('post_id')
post = Post.get_or_404(hash_id)
query = Comment.query.filter(Comment.post_id == post.id).order_by(
Comment.thread_timestamp.desc(), Comment.path.asc())
return jsonify([i.to_dict() for i in query.all()])
def add_post(title, content=None):
post = Post(content=content, title=title)
db.session.add(post)
db.session.commit()
return post.to_dict()
