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 _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'])  #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 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 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 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 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 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 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 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 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)