Python models.Blog类代码示例

 def post(self):
   """
   Post method to like and unlike blogs
   """
   if self.user:
     if self.request.get("like_blog"):
       _blog_id = self.request.get("like_blog")
       user = self.user
       user_id = user.key.id()
       _user = User.by_id(int(user_id))
       _blog = Blog.get_by_id(int(_blog_id))
       like = Like(user=user.key, blog=_blog.key)
       like.like = 1
       like_key = like.put()
       blog = _blog.key.get()
       blog.likes.append(like_key)
       blog.put()
       self.redirect('/')
     if self.request.get("dislike"):
       _blog_id = self.request.get("dislike")
       user = self.user
       user_id = user.key.id()
       _user = User.by_id(int(user_id))
       _blog = Blog.get_by_id(int(_blog_id))
       like = Like.query(Like.user == user.key, Like.blog == _blog.key).get()
       like_key = like.key
       blog = _blog.key.get()
       blog.likes.remove(like_key)
       blog.put()
       like_key.delete()
       self.redirect('/')
   else:
     self.redirect('/login')

    def post(self):
        update = self.request.get('update', False)
        cate_name = self.request.get('cate_name')
        tags_list = self.request.get_all('tags_name', [])
        title = self.request.get('title')
        blog = self.request.get('blog')
        if not blog:
            self.response.write('blog content empty!')

        cate = Category.query(Category.title==cate_name).get()
        if not cate:
            cate = Category(title=cate_name)
            cate.put()
        print tags_list
        tags = Tag.query(Tag.title.IN(tags_list)).fetch()
        tags_old = [tag.title for tag in tags]
        tags_new = []
        for tag in tags_list:
            if tag not in tags_old:
                tag = Tag(title=tag)
                tag.put()
                tags_new.append(tag)
        print tags
        print tags_new
        tags += tags_new
        print tags
        print '==='
        print dir(tags[0])
        tags = [tag.key for tag in tags]

        blog = Blog(title=title, text=blog, category=cate.key, tags=tags)
        blog.put()
        self.response.write('blog publish success')
        self.response.set_status(200)

def _get_blogs_by_page():
	total = Blog.count_all()
	
	page = Page(total, _get_page_index())
	blogs = Blog.find_by(' order by create_at desc limit ?,?', page.offset, page.limit)
	
	return blogs,page

def api_create_blog(request, *, name, summary, content, hide, categorys_tag):
    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 not hide:
        hide = False
    if not categorys_tag:
        raise APIValueError('categorys_tag', 'categorys_tag cannot be empty.')
    categorys_bit = yield from categorys_tag2bit(categorys_tag)
    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(),
        hide=hide,
        categorys_bit=categorys_bit
        )
    yield from blog.save()
    return blog

    def test_get_select_posts_bytag(self):
        blog = Blog('tests/data/feed.xml')

        selected = blog.select_posts_bytag(u'鏡館')

        for p in selected:
            self.assertTrue(u'鏡館' in p.tags)

def update_blog(request):
    """
    Expects:{"username":"[email protected]","name":"Default","content":"This is some HTML"}\n

    1.Updates article for user\n
    2.Ensures unique blog name , (can be replaced by an custom ID field to allow duplicate blogs)\n
    3.Checks if the blogs username is registered
    4.Checks if the owner of the article in request is actually the owner

    TODO : Verify user login via session / Use PUT instead of POST / Use Partial update
    """

    if request.method == 'POST':

        queryset = Blog.objects.all()
        serializer = BlogSerilizer(data=request.data)
        updated_blog = request.data['name']
        userset = User.objects.all()

        for user in userset:
            if user.username == request.data['username']:
                for blogs in queryset:
                    if updated_blog == blogs.name:
                        if blogs.username == request.data['username']:
                            if serializer.is_valid():
                                blog_id = blogs.id
                                blog_obj = Blog(id=blog_id, name=updated_blog, content=request.data['content'],
                                                username=request.data['username'])
                                blog_obj.save(force_update=True)
                                return Response(serializer.data, status=status.HTTP_201_CREATED)
        return Response(status=status.HTTP_412_PRECONDITION_FAILED)

def blog_add():
    user_now = current_user()
    blog = Blog(request.form)
    blog.user = user_now
    blog.save()
    log('发布成功')
    return redirect(url_for('timeline_view', username=user_now.username))

def blog_add(request):
    if request.method == 'POST':
        form = BlogForm(request.POST)
        tag = TagForm(request.POST)
        if form.is_valid() and tag.is_valid():
            cd = form.cleaned_data
            cdtag = tag.cleaned_data
            tagname = cdtag['tag_name']
            for taglist in tagname.split():
                Tag.objects.get_or_create(tag_name=taglist.strip())
            title = cd['caption']
            author = Author.objects.get(id=1)
            content = cd['content']
            blog = Blog(caption=title, author=author, content=content)
            blog.save()
            for taglist in tagname.split():
                blog.tags.add(Tag.objects.get(tag_name=taglist.strip()))
                blog.save()
            id = Blog.objects.order_by('-publish_time')[0].id
            return HttpResponseRedirect('blog/%s' % id)
    else:
        form = BlogForm()
        tag = TagForm(initial={'tag_name': 'notags'})
    return render_to_response('blog_add.html',
        {'form': form, 'tag': tag}, context_instance=RequestContext(request))

def index(request):
    context = base_context()
    rpp = record_per_page()
    cur_page = 1
    try:
        cur_page = int(request.REQUEST["jumpPage"].strip())
    except:
        cur_page = 1

    blogs_count = Blog.all().count()
    max_page = blogs_count / rpp
    temp2 = blogs_count % rpp
    if temp2 != 0:
        max_page = max_page + 1

    if cur_page > max_page or cur_page <= 0:
        cur_page = max_page
        blogs = Blog.all().order("-date").fetch(0)
    else:
        blogs = Blog.all().order("-date").fetch(rpp, rpp * (cur_page - 1))

    context.cur_page = cur_page
    context.max_page = max_page
    context.action_mode = "/"
    context.range1 = range(1, max_page + 1)
    context.up_page = cur_page - 1
    context.down_page = cur_page + 1
    context.blogs = blogs
    template = loader.get_template("blogs/index.html")
    return HttpResponse(template.render(context))

    def Post(self):
        title = self.Request.get("title")
        content = self.Request.get("content")

        blog = Blog(title=title, content=content)
        blog.put()
        return webapp2.redirect("/blog")

def api_create_blog(request, *, name, summary, content):
    # 校验当前用户权限：
    check_admin(request)
    # 校验传递值中参数‘name’是否为空或空串,为空则抛出异常：
    if not name or not name.strip():
        # 参数‘name’为空则抛出异常：
        raise APIValueError("name", "name cannot be empty.")
    # 校验传递值中参数‘summary’是否为空或空串,为空则抛出异常：
    if not summary or not summary.strip():
        raise APIValueError("summary", "summary cannot be empty.")
    # 校验传递值中参数‘content’是否为空或空串,为空则抛出异常：
    if not content or not content.strip():
        raise APIValueError("content", "content cannot be empty.")
    # 创建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(),
    )
    # 将Blog信息存储到数据库：
    yield from blog.save()
    return blog

def api_delete_blog(blog_id):
    check_admin()
    blog = Blog.get(blog_id)
    blog = Blog.get(blog_id)
    if blog is None:
        raise APIResourceNotFoundError("Blog")
    blog.delete()
    return dict(id=blog_id)

def api_index(*, page="1"):
    page_index = get_page_index(page)
    num = yield from Blog.findNumber("count(id)")
    p = Page(num, page_index, page_size=5)
    if num == 0:
        return dict(page=p, blogs=())
    blogs = yield from Blog.findAll(orderBy="created_at desc", limit=(p.offset, p.limit))
    return dict(page=p, blogs=blogs)

def api_blogs(*, page='1'):
    page_index = get_page_index(page)
    num = yield from Blog.findNumber('count(id)')
    p = Page(num, page_index)
    if num == 0:
        return dict(page=p, blogs=())
    blogs = yield from Blog.findAll(orderBy='created_at desc', limit=(p.offset, p.limit))
    return dict(page=p, blogs=blogs)

 def test_single_existence(self):
     """Test that the blog is created only once """
     self.blog = Blog(title = "test",tag_line = "new blog",entries_per_page=10,recents = 5, recent_comments = 5)
     self.blog.save()
     blog = Blog(title = "test",tag_line = "new blog",entries_per_page=10,recents = 5, recent_comments = 5)
     #should raise Exception when another blog is created
     self.assertRaises(Exception,blog.save())
     self.blog.delete()