def api_create_blog(request, *, name, summary, content):
check_admin(request)
if not name or not name.strip():
raise APIValueError('name', 'name cannot be empty.')
if not summary or not summary.strip():
raise APIValueError('summary', 'summary cannot be empty.')
if not content or not content.strip():
raise APIValueError('content', 'content cannot be empty.')
blog = Blog(user_id=request.__user__.id, user_name=request.__user__.name, \
user_image=request.__user__.image, name=name.strip(), \
summary=summary.strip(), content=content.strip())
yield from blog.save()
return blog
def setUp(self):
self.blog = Blog(title="test",
tag_line="new blog",
entries_per_page=10,
recents=5,
recent_comments=5)
self.blog.save()
self.c = Client()
self.user = User.objects.create_user(username='******',
email='*****@*****.**',
password='******')
self.user.is_staff = True
self.user.save()
def newpost():
if request.method == "POST":
title = request.form['title']
body = request.form['body']
if title.strip() == '' or body.strip() == '':
flash('please enter text within the fields')
return redirect('/newpost')
new_post = Blog(title, body, owner=current_user)
db.session.add(new_post)
db.session.commit()
return redirect('/blog?id=' + str(new_post.id))
return render_template("newpost.html")
def post(self):
"""Handles a post request to create a blog entry."""
title = self.request.get('title').strip()
title = util.squeeze(title, string.whitespace)
text = self.request.get('text').strip()
text = util.squeeze(text, string.whitespace)
blog = Blog(user=self.user.key, title=title, text=text)
try:
blog.put()
except ndb.TransactionFailedError:
# TODO: Handle error
return self.redirect('/')
else:
return self.redirect('/blog/%s' % blog.key.urlsafe())
def new_post():
username = session['user']
if request.method == 'GET':
if request.args:
title = request.args.get('title')
body = request.args.get('body')
keywords = request.args.get('keywords')
return render_template('newpost.html',
title=title, body=body, keywords=keywords, user=username)
else:
return render_template('newpost.html', user=username)
elif request.method == 'POST':
# collect form data, validate, add to db
title = request.form['title']
body = request.form['body']
keywords = request.form['keywords']
# TODO: validate and redirect to newpost page with error msgs
if not title or not body:
flash('Title and body fields are required.')
return redirect('/newpost?title={0}&body={1}&keywords={2}'.format(
title, body, keywords))
elif len(title) > 120 or len(body) > 10000:
flash('Title or body of post is too long. Title max is 120 char; body max is 10000 char.')
return redirect('/newpost?title={0}&body={1}&keywords={2}'.format(
title, body, keywords))
# get user id
username = session['user']
user = User.query.filter_by(username=username).first()
owner_id = user.user_id
# create Blog object and add to db
new_blog = Blog(owner_id, title, keywords, body)
db.session.add(new_blog)
db.session.commit()
# pass form data to viewpost.html and render it
return redirect('/viewpost?id={0}'.format(new_blog.blog_id))
else:
return redirect('/blog')
def api_create_blog(request, *, name, summary, content):
# print('the request is: %s' % request)
check_actived(request)
# print('Save blogs to the database......')
if not name or not name.strip():
raise APIValueError('name', 'name cannot be empty.')
if not summary or not summary.strip():
raise APIValueError('summary', 'summary cannot be empty.')
if not content or not content.strip():
raise APIValueError('content', 'content cannot be empty.')
blog = Blog(user_id=request.__user__.id, user_name=request.__user__.name, user_image=request.__user__.image, name=name.strip(), summary=summary.strip(), content=content.strip())
r = yield from blog.save()
print(r)
return blog
async def do_editor_post(
opr_type,title,text,md,html,description,author,info,category,tags,id,
digest,keywords,fields,format_used,mood,status,visible
):
# 数据检查和处理
created_at=time.time()
b=Blog(
title=title,text=text,md=md,format_used=format_used,html=html,
created_at=created_at,category=category,tags=tags,id=id,author=author,
description=description,info=info,digest=digest,keywords=keywords,fields=fields,
mood=mood,status=status,visible=visible
)
await man.upsertBlogSafe(b)
return jsonResponse(success=True,message='上传成功！')
async def api_create_blog(request, *, name, summary, content):
# 检查登录用户是否为管理员
check_admin(request)
if not name or not name.strip():
raise APIValueError('name', 'name cannot be empty.')
if not summary or not summary.strip():
raise APIValueError('summary', 'summary cannot be empty.')
if not content or not content.strip():
raise APIValueError('content', 'content cannot be empty.')
# 构建博客数据
blog = Blog(user_id=request.__user__.id, user_name=request.__user__.name, user_image=request.__user__.image, name=name.strip(), summary=summary.strip(), content=content.strip())
# 保存
await blog.save()
return blog
async def testBlog():
await orm.create_pool(loop=loop,
host='10.4.67.111',
port=3306,
user='******',
password='******',
db='awesome')
m = Blog(user_id='11',
user_name='user_name',
user_image="about:blank",
name="hello",
summary="summary",
content="content")
await m.save()
async def index(request):
# resp = web.Response(text="<h1>Awesome</h1>")
# # (body=b'<div><h1>Awesome</h1></div>')
# resp.content_type = 'text/html'
# return resp
# users = await User.findAll()
summary = "Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et" \
" dolore magna aliqua."
blogs = [
Blog(id='1',
name='Test Blog',
summary=summary,
created_at=time.time() - 120),
Blog(id='2',
name='Something New',
summary=summary,
created_at=time.time() - 3600),
Blog(id='3',
name='Learn Swift',
summary=summary,
created_at=time.time() - 7200)
]
return {'__template__': 'bolgs.html', 'blogs': blogs}
def addblog():
if sys.getdefaultencoding() != 'utf-8':
reload(sys)
sys.setdefaultencoding('utf-8')
title = request.values.get('articlename')
content = request.values.get('editor1')
dr = re.compile(r'<[^>]+>', re.S)
dd = dr.sub('', content)
content_outline = dd[0:135] + '……'
user_id = current_user.id
blog = Blog(title, content, content_outline, user_id)
db.session.add(blog)
db.session.commit()
return redirect('/profile')
def index(request, *args, **kwargs):
context = {'categories': CATEGORIES}
if request.method == "POST":
content = request.POST.get('content')
title = request.POST.get('title') or None
user = request.POST.get('user') or None
category = request.POST.get('category')
try:
b = Blog(content=content, title=title, user=user, category=category)
b.save()
except Exception as why:
context['error'] = why
context['blogs'] = Blog.objects.filter(accepted=True)
return render(request, 'index.html', context)
def editblog(request, id):
if Blog.exists(id):
# find an existing article
print "The article exists wihiii"
blog = Blog.get_by_id(id)
else:
# create a new article
blog = Blog()
blog.timestamp = datetime.now()
blog.save()
if request.method == "POST" and request.POST.has_key(
"content") and request.POST.has_key("version"):
edited_version = int(request.POST["version"])
print "Version of the blog: " + str(edited_version)
content = request.POST["content"]
if edited_version == blog.version:
# a valid POST request: save the new contents of the article
# Always clean the input from the user
blog.content_body = content
blog.title = request.POST["title"]
blog.timestamp = datetime.now()
blog.version += 1
blog.save()
request.session['blogs_edited'] += 1
# Always redirect after a successful POST request
return HttpResponseRedirect('/myblog/')
else:
print "Version of the blog in conflict: " + str(edited_version)
return render_to_response("conflict.html", {
'title': blog.title,
'content': blog.content_body,
'user_content': content,
'id': blog.id,
'version': blog.version
},
context_instance=RequestContext(request))
else:
print "No se ha hecho ekl post"
# a GET request or a POST request using the worng form: show the form
return render_to_response("edit.html", {
'id': blog.id,
'title': blog.title,
'content': blog.content_body,
'version': blog.version
},
context_instance=RequestContext(request))
def new_post():
back = session['back']
session['back'] = request.endpoint
title = ""
body = ""
id = ""
editing = False
current_user = User.get_user(session['email'])
if request.method == 'GET':
try:
id = request.args.get('id')
except:
pass
if id:
blog = Blog.get(None, id)
title = blog.title
body = blog.body
id = blog.id
editing = True
if request.method == "POST":
title = request.form['title']
body = request.form['body']
try:
editing = request.form['editing']
except:
pass
if editing:
id = request.form['id']
if current_user and title and body:
if not editing:
blog = Blog(title, body, current_user,
datetime.date.today().strftime('%b %d, %Y'))
else:
if id:
blog = Blog.get(None, id)
blog.title = title
blog.body = body
Blog.add(blog)
return redirect("/blog?blog-id=" + str(blog.id))
else:
flash("Please fill out all fields", "Error")
return render_template("new_post.html",
title=title,
body=body,
editing=editing,
id=id,
back=back)
def newpost():
if request.method == 'POST':
db_session = session()
title = request.form['title']
catagory = request.form['catagory']
auther = request.form['auther']
content = request.form['content']
entry = Blog(title=title,
catagory=catagory,
auther=auther,
content=content)
db_session.add(entry)
db_session.commit()
return redirect(url_for('index'))
async def index(request):
# users = await User.findAll()
summary = 'Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.'
blogs = [
Blog(id='1',
name='Test Blog',
summary=summary,
created_at=time.time() - 120),
Blog(id='2',
name='Something New',
summary=summary,
created_at=time.time() - 3600),
Blog(id='3',
name='Learn Swift',
summary=summary,
created_at=time.time() - 7200)
]
return {
'__template__': 'blogs.html',
# 'users': users,
'blogs': blogs
}
async def api_create_blog(request,
*,
id=None,
user_id=None,
user_name=None,
user_image=None,
created_at=None,
name,
summary,
content):
check_admin(request)
if not name or not name.strip():
raise APIValueError('name', 'name cannot be empty.')
if not summary or not summary.strip():
raise APIValueError('summary', 'summary cannot be empty.')
if not content or not content.strip():
raise APIValueError('content', 'content cannot be empty.')
if id != None:
blog = Blog(id=id,
user_id=user_id,
user_name=user_name,
user_image=user_image,
created_at=created_at,
name=name.strip(),
summary=summary.strip(),
content=content.strip())
await blog.update()
pass
else:
blog = Blog(user_id=request.__user__.id,
user_name=request.__user__.name,
user_image=request.__user__.image,
name=name.strip(),
summary=summary.strip(),
content=content.strip())
await blog.save()
return blog
async def api_create_blog(request, *, name, summary, content):
check_admin(request)
if not name or not name.strip():
APIError('name', 'name cannot be empty.')
if not summary or not summary.strip():
APIError('summary', 'summary cannot be empty.')
if not content or not content.strip():
APIError('content', 'content cannot be content.')
u_id = request.__user__.id
u_name = request.__user__.name
u_image = request.__user__.image
blog = Blog(user_id=u_id, user_name=u_name, user_image=u_image,
name=name.strip(), summary=summary.strip(), content=content.strip())
await blog.save()
return blog
def addEntry():
if request.method == "POST":
title = request.form['title']
titleError = verifyTitle(title)
entry = request.form['body']
owner = User.query.filter_by(username=session['username']).first()
entryError = veryifyEntry(entry)
if title != titleError:
return render_template('addentry.html', titleError=titleError, entry=entry, entryError=entryError)
tagline = verifyTag(request.form['tagline'], entry)
newEntry = Blog(title, tagline, entry, owner)
db.session.add(newEntry)
db.session.commit()
return redirect("/thankyou?title=" + title)
return render_template('addentry.html', username=session['username'])
async def api_create_blog(request, *, name, summary, content):
check_admin(request) # 验证权限
# 参数校验
if not name or not name.strip():
raise APIValueError('name', 'name cannot be empty.')
if not summary or not summary.strip():
raise APIValueError('summary', 'summary cannot be empty.')
if not content or not content.strip():
raise APIValueError()
# 封装Blog对象
blog = Blog(user_id=request.__user__.id, user_name=request.__user__.name, user_image=request.__user__.image,
name=name.strip(), summary=summary.strip(), content=content.strip())
# 保存到数据库
await blog.save()
return blog
def blog_add():
form = request.get_json()
log('发回的md格式文章：', form)
blog = Blog(form)
blog.created_time = time.time()
blog.save()
response = {
'id': blog.id,
'success': True,
'title': blog.title,
'content': blog.content,
'created_time': blog.created_time,
}
log('发回前端的文章信息:', jsonify(response))
return jsonify(response)
def api_create_blog():
i = ctx.request.input(name='',summary='',content='')
name = i.name.strip()
summary = i.summary.strip()
content = i.content.strip()
if not name:
raise APIValueError('name','name cannot be empty.')
if not summary:
raise APIValueError('summary','summary cannot be empty.')
if not content:
raise APIValueError('content','content cannot be empty.')
user = ctx.request.user
blog = Blog(user_id=user.id,user_name=user.name,name=name,summary=summary,content=content)
blog.insert()
return blog
async def api_blog_edit(id, request, *, name, summary, content):
check_admin(request)
if not name or not name.strip():
raise APIValueError('name', '标题不能为空')
if not summary or not summary.strip():
raise APIValueError('summary', '摘要不能为空')
if not content or not content.strip():
raise APIValueError('content', '内容不能为空')
blog = Blog(user_id=request.__user__.id, user_name=request.__user__.name, user_image=request.__user__.image,
name=name.strip(), summary=summary.strip(), content=content.strip())
sql = 'UPDATE `blogs` SET `name` = "%s", `summary` = "%s", `content` = "%s", `update_time` = "%s" WHERE `id` = %s'\
% (name.strip(), summary.strip(), content.strip(), get_time(), id)
print(sql)
await blog.sql_execute(sql)
return blog
async def addTestBlogs(tb,force=False):
articles=loadTestBlogs()
for a in articles:
if not force and tb._exists(title=a.title):
print('blog exists: %s'%a.title)
continue
blog=Blog(title=a.title,description=a.intro,info=a.info,text=a.content,
category='Demo',html=textToHTML(a.content),created_at=time.time(),
tags=['demo']
)
# print('Blog __dict__:',Blog.__dict__)
await tb.insert(blog)
blog=await tb.find(title=blog.title)
print(blog.__class__)
log('insert blog %s and id=%s'%(blog['title'],blog.id))
def test():
yield from orm.create_pool(loop=aloop,
user='******',
password='******',
db='awesome')
blog = Blog(id=2,
user_id='00151742755147359f8f21f530043e7b5c7ed2eace44692000',
user_name='*****@*****.**',
user_image='about:blank',
name='dfdsaf',
summary='dfasdfasdfads',
content='fdasfasdfasd')
#u = User(name = 'test', email = '*****@*****.**', passwd ='1234556677', image = 'about:blank')
yield from blog.save()
async def api_create_blog(request, *, name, summary, content):
check_admin(request)
if not name:
raise APIValueError('name', 'name cannot be empty')
if not summary:
raise APIValueError('summary', 'summary cannot be empty')
if not content:
raise APIValueError('content', 'content cannot be empty')
blog = Blog(user_id=request.__user__.id,
user_name=request.__user__.name,
user_image=request.__user__.image,
name=name.strip(),
summary=summary.strip(),
content=content.strip())
await blog.save()
return blog
async def api_create_blog(request, *, title, summary, content):
check_admin(request=request)
if not title or not title.strip():
raise APIValueError('title', 'title cannot be empty.')
if not summary or not summary.strip():
raise APIValueError('summary', 'summary cannot be empty.')
if not content or not content.strip():
raise APIValueError('content', 'content cannot be empty.')
blog = Blog(user_id=request.__user__.id,
user_name=request.__user__.name,
user_avatar=request.__user__.avatar,
title=title.strip(),
summary=summary.strip(),
content=content.strip())
await blog.save()
return blog
async def create_blogs(request, *, name, content, summary):
check_admin(request)
if not name or not name.strip():
raise APIValueError('name', 'name can not empty.')
if not summary or not summary.strip():
raise APIValueError('summary', 'summary can not empty.')
if not content or not content.strip():
raise APIValueError('content', 'content can not empty.')
blog = Blog(user_id=request.__user__.id,
user_name=request.__user__.name,
user_image=request.__user__.image,
summary=summary.strip(),
name=name.strip(),
content=content.strip())
await blog.save()
return blog
async def api_create_blog(request, *, name, summary, content, readable):
if not name or not name.strip():
raise APIValueError('name', 'name cannot be empty.')
if not summary or not summary.strip():
raise APIValueError('summary', 'summary cannot be empty.')
if not content or not content.strip():
raise APIValueError('content', 'content cannot be empty.')
blog = Blog(user_id=request.__user__.id,
user_name=request.__user__.name,
user_image=request.__user__.image,
name=name.strip(),
summary=summary.strip(),
content=content.strip(),
readable=readable)
await blog.save()
return blog
def parse(rpc_raw, op_return_data, from_user_address, block_index, tx_id,
block_time):
from models import Blog
if op_return_data[2:5] == "blg": #Non-Encrypted Blog Post
if not Blog.objects.filter(key=op_return_data[5:]).exists():
print "Found blogpost"
new_blog = Blog(
**{
"address_from": from_user_address,
"block_index": block_index,
"tx_id": tx_id,
"msg": "",
"key": op_return_data[5:],
"time": block_time
})
new_blog.save()
