def _create_new_account(self):
title = input("Title of the blog? ")
description = input("Description of the blog? ")
blog = Blog(self.user, title, description)
# no need to create new_post() because we are essentially creating a new account.
blog.save_to_mongo()
self.user_blog = blog
def new_blog(self, title, description):
blog = Blog(author=self.email,
title=title,
description=description,
author_id=self._id)
blog.save_to_mongo()
def _prompt_user_for_account(self):
title = input("Enter blog title: ")
description = input("Enter blog description: ")
blog = Blog(author=self.user,
title=title,
description=description)
blog.save_to_mongo()
self.user_blog = blog
def create_new_blog():
if request.method == 'GET':
return render_template('new_blog.html')
else:
title = request.form['title']
description = request.form['description']
user = User.get_by_email(session['email'])
new_blog = Blog(user.email, title, content, user._id)
new_blog.save_to_mongo()
return make_response(user_blogs(user._id))
def new_blog(self, title, description):
"""new_blog(str, str) -> return(None)
title : The title for the new blog
description: The description for the new blog
Creates a new blog.
"""
blog = Blog(author=self.email,
title=title,
description=description,
author_id=self._id)
blog.save()
def _user_exists(self):
blog = Database.find_one('blogs', {"author": self.user})
if blog is not None:
self.user_blog = Blog.from_mongo(blog['id'])
return True
else:
return False
def get(self, tag_id):
data = {
'title': 'Tag | 博客',
'blogs': Blog.get_blog_by_tag_id(tag_id),
'all_tag': BlogTags.get_all_tags(),
}
self.render('purecss_ui/blog_tag.html', **data)
def _user_has_account(self):
blog = Database.find_one('blogs', {'author': self.user})
if blog is not None:
self.user_blog = Blog.from_mongo(blog['id']) #si le asigno la variable blog queda la info pero user_blog no seria un objeto. de esta manera traigo el objeto con el metodo from_mongo
return True
else:
return False
def _view_blog(self):
blog_to_see = input("Enter the ID of the blog you'd write to read: ")
blog = Blog.from_mongo(blog_to_see)
posts = blog.get_posts()
print('----------------------------')
for post in posts:
print("Date: {}, Title: {}\n{}\n----------------------------".format(post['created_date'], post['title'], post['content']))
def _user_has_account(self):
blog = Database.find_one("blogs", {"author": self.user})
if blog is not None:
self.user_blog = Blog.from_mongo(blog["id"])
return True
else:
return False
def _user_has_account(self):
blog = Database.find_one('blogs', {'author': self.user})
if blog is not None:
self.user_blog = Blog.from_mongo(blog['id'])
return True
else:
return False
def get(self, category_id):
data = {
'title': 'Category | 博客',
'blogs': Blog.get_blog_by_category_id(category_id),
'all_category': BlogCategory.get_all_category()
}
self.render('purecss_ui/blog_category.html', **data)
def get(self, request, blog_id):
try:
blog = Blog.objects(id = ObjectId(blog_id)).first()
message = blog.to_json()
except:
message = {"error": "Blog not found"}
return HttpResponse(dumps(message))
def _read_blog():
blog_to_see = input("Enter the ID of the blog you want to read: ")
blog = Blog.from_mongo(blog_to_see)
posts = blog.get_posts()
for post in posts:
print("\nDate: {} | ID: {}\nTitle: {}\n\n{}".format(
post['date'], post['id'], post['title'], post['content']))
print('\n')
def _view_blog(self):
blog_to_see = input("Enter the ID of the blog you'd like to read: ")
blog = Blog.from_mongo(blog_to_see)
posts = blog.get_posts()
for post in posts:
print(
f"Date: {post['created_date']}, Title: {post['title']}/n/n{post['content']}"
)
def footer_info(self):
try:
blog_obj = Blog.get(Blog.id == 1)
footer_text = blog_obj.copyright
return footer_text
except Exception as e:
Logger().log(e, True)
return server_error
def blog_posts(blog_id):
user = User.get_by_email(session['email'])
blogs = user.get_blogs()
blog = Blog.from_mongo(blog_id)
posts = blog.get_posts()
return render_template('posts.html', posts=posts, blog_title=blog.title, blog_id=blog._id,blogs=blogs, email=user.email)
def _view_blog(self):
blog_to_see = input("Input the ID of the blog you'd like to read: ")
blog = Blog.from_mongo(blog_to_see)
posts = blog.get_posts()
for post in posts:
print(
f"Title: {post['title']}, Date: {post['date']}\n\n{post['content']}"
)
def _user_has_account(self):
blog = Database.find_one(collection='blogs',
query={"author": self.user})
if blog is not None:
self.user_blog = Blog.from_mongo(blog['id'])
return True
else:
return False
def _user_has_account(self):
#check if user already has account
blog = Database.find_one('blogs', {"author": self.user})
if blog is not None:
self.user_blog = Blog.get_from_mongo(blog['id'])
return True
else:
return False
def view_blog(self):
blog_to_see = input("Enter de ID of the blog you would like to see: ")
blog = Blog.from_mongo(blog_to_see)
posts = blog.get_posts()
for post in posts:
print("Date {}, Title {}\n\n{}".format(post['create_date'],
post['title'],
post['content']))
def __user_has_account(self):
blog = Database.find_one('blogs', {'author': self.user})
if blog is not None:
self.user_blog = Blog.from_mongo(blog['id'])
return True
else:
return False
def blog_add():
form = request.form.to_dict()
if request.method == 'POST':
u = current_user()
print('blog_add form = <{}>'.format(form))
b = Blog.new(form=form, user_id=u.id)
return redirect(url_for('.blog_index'))
return render_template('blog/blog_add.html', form=form)
def _view_blog(self):
blog_to_see = input("enter id of blog to see")
blog = Blog.from_mongo(blog_to_see)
posts = blog.get_posts()
for post in posts:
print("Date: {}. title: {}\n\n{}".format(post['created_date'],
post['title'],
post['content']))
def get_blog(username, user_blog_id):
try:
user_blog_id = int(user_blog_id)
except ValueError:
raise ArgsError('Require {} type {}, but found {}'.format("user_blog_id", int, type(user_blog_id)))
blog = Blog.get_blog(username, user_blog_id)
return jsonify(blog.to_json())
def _view_blog(self):
blog_to_see = input("Enter the ID of the blog you'd like to read: ")
blog = Blog.from_mongo(blog_to_see)
posts = blog.get_posts()
for post in posts:
print("Date: {}, title: {}\n\n{}".format(post['created_date'],
post['title'],
post['content']))
def blog_posts(blog_id):
blog = Blog.from_mongo(blog_id)
posts = blog.get_posts()
return render_template('posts.html',
posts=posts,
blog_title=blog.title,
blog_id=blog._id)
def add_blog():
if not current_user.is_admin:
return {'success': False, 'err': 'No permissions'}
req_data = request.get_json()
if not ('uid' in req_data and 'name' in req_data and 'author' in req_data
and 'date' in req_data and 'content' in req_data):
return {'success': False, 'err': 'Invalid request body'}
new_blog = Blog(_uid=req_data['uid'],
_name=req_data['name'],
_author=req_data['author'],
_date=req_data['date'],
_content=req_data['content'])
new_blog.put()
return {'success': True}
def _user_has_account(self):
blog = Database.find_one(collection='blogs',
query={'author': self.user})
print('user_data', blog)
if blog is None:
return False
else:
self.user_blog = Blog.get_blog(blog['id'])
return True
def _view_blog(self):
blog_id = input('Enter ID of the blog you want to read ')
blog = Blog.get_blog(blog_id)
posts = blog.get_posts()
for post in posts:
print('Title: {} '
'Date: {} '
'Content: {}'.format(post['title'], post['date'],
post['content']))
def _view_blog(self):
blog_to_see = input("enter the id of the blog you want to read: ")
blog = Blog.from_mongo(blog_to_see)
posts = blog.get_posts()
print(blog.id, blog.title)
for post in posts:
print("Date: {}, Title {} \n\n{}".format(post['date'],
post['title'],
post['comment']))
def _view_blog(self):
text = input("Which Blog do you want to view (id) ? :")
blog = Blog.get_from_mongo(text)
lis = blog.get_posts()
print("\t\t\t\t\t{}\t\tBy Author : {}\t\t\t\n".format(
blog.title, blog.author))
for i in lis:
print("ID : {}\tTITLE : {}\tCONTENT : {}\tDATE : {}\n".format(
i['id'], i['title'], i['content'], i['created_date']))
def _user_has_account(self):
try:
sr = Database.find_one(collection="blogs",
query={"author": self.user})
a = sr[0]
self.user_blog = Blog.get_from_mongo(sr[0]['id'])
return True
except IndexError:
return False
def get(self, blog_id):
data = {
'title': 'blog | detail',
'blog': Blog.get_blog(blog_id),
'all_tag': BlogTags.get_all_tags(),
'all_category': BlogCategory.get_all_category(),
}
self.render('purecss_ui/blog_detail.html', **data)
def _user_has_account(self):
"""Check is user has already signed up for blogs"""
blog = Database.find_one('blogs', {'author': self.user})
if blog is not None:
self.user_blog = Blog.from_mongo(blog['id'])
return True
else:
return False
def f():
data, u = request_data()
comment_id = data.get('id')
c = Comment.find(comment_id)
if u.id == c.user_id:
return route_function()
else:
blog = Blog.find(c.blog_id)
return redirect(url_for('routes_blog.detail', blog_id=blog.id))
def love_blog(username, user_blog_id):
try:
user_blog_id = int(user_blog_id)
except ValueError:
raise ArgsError('Require {} type {}, but found {}'.format("user_blog_id", int, type(user_blog_id)))
incr_value = Blog.love_blog(g.current_user.id, username, user_blog_id)
return jsonify({
"success": incr_value,
});
def _view_blogs(self):
blog_to_see = input(
"Enter the id of the blog you would like to read!: ")
blog = Blog.from_mongo(blog_to_see)
posts = blog.get_posts()
for post in posts:
print("Date: {}, Title: {} \n\n{}".format(post['date'],
post['title'],
post['content']))
def create(cls, blog_id, content, creator_id):
sql = 'insert into {} (blog_id,content,creator_id) values(%s, %s, %s)'.format(cls.__table__)
params = (blog_id, content, creator_id)
id = store.execute(sql,params)
store.commit()
if id:
blog = Blog.get(blog_id)
blog.add_comment_count(1)
return id
def delete_entry(identifier):
item = Blog.get(int(identifier))
if not item: return mismatch()
ownership = (item.author == g.user)
if access(request.path, g.role.id, ownership) != 1: return forbidden()
headline = "%s löschen?" % (item.title)
text = "Menü %s wirklich löschen?" % (item.title)
return delete_form(item, headline, text, "Deleted blog entry.", "/blog",
"/blog/%s" % (identifier))
def _user_has_account(self):
# find one blog that has the author as the user entered
# will return True or False
blog = Database.find_one('blogs', {'author': self.user})
if blog is not None:
self.user_blog = Blog.from_mongo(blog['id'])
return True
else:
return False
def get(self, blog_id):
data = {
'title': 'blog | detail',
'blog': Blog.get_blog(blog_id),
'all_tag': BlogTags.get_all_tags(),
'all_category': BlogCategory.get_all_category(),
}
self.render('purecss_ui/blog_detail.html', **data)
def edit():
u = current_user()
blog_id = request.args.get('id', -1)
b = Blog.find(blog_id)
boards = Board.all()
return render_template('routes_blog/blog_edit.html',
blog=b,
u=u,
boards=boards)
def _user_has_account(self):
# should return True or Fslse
blog = Database.find_one('blogs', {'author': self.user})
if blog is not None:
# create an object
self.user_blog = Blog.from_mongo(blog['id'])
return True
else:
return False
def _user_has_account(self):
# check to see if there is a blog with this author name
# below: find one blog that has the author as the user (which was entered)
blog = Database.find_one('blogs', {'author': self.user}) ## is not None
if blog is not None:
self.user_blog = Blog.from_mongo(blog['id'])
return True
else:
return False
def get(self, blog_id):
blog = Blog.get_blog(blog_id)
data = {
'title': '修改 | 博客',
'blog': blog,
'tags': BlogTags.get_all_tags(),
'category': BlogCategory.get_all_category()
}
self.render('admin/admin_blog_modify.html', **data)
def blog_show(blog_id):
blog = Blog.get(blog_id)
user = get_user()
if not user:
is_join = False
else:
is_join = blog.get_is_join(user.id)
comment_list = Comment.get_comments(blog_id)
return header_render('blog_show.html', blog=blog, comment_list = comment_list,
is_join = is_join)
def get(self):
search = self.get_argument('search', '')
data = {
'title': '搜索',
'query': search,
'blog': Blog.search_blog(search),
'tag': BlogTags.search_tags(search),
'category': BlogCategory.search_category(search)
}
self.render('search_result.html', **data)
def group_show(group_id):
group = Group.get(group_id)
if group:
creator = doubanusers.User(id=group.creator_id)
blog_list = Blog.get_all_by_group(group_id)
is_join = group.get_is_join(get_user().id)
member_list = group.get_members()
return header_render('group_show.html',group=group, creator = creator,
blog_list = blog_list, is_join = is_join, member_list = member_list)
else:
abort(404)
def blog_create(group_id):
group = Group.get(group_id)
if request.method == 'POST':
title = request.form['blog_title']
content = request.form['blog_content']
id = Blog.create(title, content, get_user().id, group_id)
if not id:
return header_render('blog_create.html', group = group)
return redirect(url_for('blog_show',blog_id = id))
else:
return header_render('blog_create.html', group = group)
def entry_newist():
try:
params = {'posted': False}
params.update(request.forms)
#logging.info(params)
cb = 'entry'
if params.get('channel', '') == 'home':
cb = 'home'
return {'publish': Blog.newist(params, cb)}
except Exception as e:
logging.info(e)
abort(500)
def new_post(blog_id, title, content, date=datetime.datetime.utcnow()):
"""new_post(str, str, str, str) -> return(None)
blog_id: The blog id to store the post within
title : The title for the new post
content: The content for the post
Creates a post for the blog
"""
blog = Blog.get_from_db(blog_id)
blog.new_post(title=title,
content=content,
blog_id=blog_id)
def user_blogs(user_id=None):
if user_id is not None:
user = User.get_by_id(user_id)
else:
user = User.get_by_email(session['email'])
blogs = user.get_blogs()
blog_id = request.args.get('bg')
if blog_id is not None:
blog = Blog.from_mongo(blog_id)
posts = blog.get_posts()
return render_template("user_blogs.html", blogs=blogs, email=user.email,posts=posts, blog_title=blog.title, blog_id=blog._id)
return render_template("user_blogs.html", blogs=blogs, email=user.email)
def entry_newist(channel, tag, offset):
try:
params = {
'posted': True,
'channel': channel,
'tags': tag,
'fetch': request.query.get('fetch'),
'offset': offset
}
call_back = 'entry'
if channel == 'home':
call_back = 'home'
return {'publish': Blog.newist(params, call_back)}
except Exception as e:
logging.error(e)
abort(500)
def get(self):
page = self.get_int('page', 1)
per_page = self.get_int('per_page', 10)
query = Blog.select().where(Blog.hide == False).order_by(Blog.id.desc())
ip = self.request.headers['X-Real-Ip']
if ip != '127.0.0.1':
AccessRecord.create_a_r(ip)
data = {
'title': 'khahux | 平凡的一生',
'paginator': Paginator(query, page, per_page),
'all_tag': BlogTags.get_all_tags(),
'all_category': BlogCategory.get_all_category()
}
self.render('purecss_ui/blog.html', **data)
def _view_blogs(self):
blog_to_see = input("Enter the ID of the blog you would like to read:")
blog = Blog.from_mongo(blog_to_see)
posts = blog.get_posts()
for post in posts:
print("Date: {},title: {}\n\n{}".format(post['created_date'],post['title'],post['content']))
def get_blogs(self):
"""Returns a list of blogs created by the user.
"""
return Blog.get_by_author_id(self._id)
def add_blog():
try:
return {'publish': Blog.save_blog(request.forms)}
except Exception as e:
logging.info(e)
abort(500)
def blog_posts(blog_id):
blog = Blog.from_mongo(blog_id)
posts = blog.get_posts()
return render_template('posts.html', posts=posts, blog_title=blog.title, blog_id=blog._id)
def delete_post(self, request):
obj = Blog.get(id=request.params[0])
if request.user == obj.author:
obj.delete()
return self.render('blog/list')
