def update_site(self):
     """Updates only the static pages"""
     files = os.listdir(self.datadir)
     for f in files:
         if f[0] != '.':  # leave out hidden files
             post = Post(self.datadir+f)
             post.write(self.posts, self.tags)

def print_post(args):
    if 'all' in args.postid:
        posts = Post.load()
    else:
        try:
            ids = [int(x) for x in args.postid]
        except ValueError:
            print('Post IDs should be numbers')
            return
        posts = Post.load(ids)
    if not len(posts):
        print('Post ID(s) not found: {}'.format(' '.join(args.postid)))
        return
    if args.s:
        posts = order_by_date(posts)
    for postid in posts.keys():
        if len(posts[postid]['body']) > 74:
            body = '\n      '.join(trunc(posts[postid]['body'], 74))
        else:
            body = posts[postid]['body']
        print('Title: {}\nPost ID: {}, last modification date: {}\nBody: {}'
              .format(posts[postid]['title'],
                      postid,
                      posts[postid]['date'],
                      body))
        print('-' * 80)

def main():	

	# READ TEMPATE HTML FILES
	base_html = open("templates/base.html")
	post_html = open("templates/post.html")

	# CREATE PAGE
	page = base_html.readlines()
	posts = []

	# OPEN POST TXT FILES
	postfiles = [ f for f in listdir("posts") if isfile(join("posts",f)) ]

	for postfile in postfiles:
		temp = open("posts/" + postfile, "r")
		postlines = temp.readlines()
		post_obj = Post(postlines[0], postlines[1], postlines[2:])
		posts.append("".join(post_obj.render(post_html)))
		post_html.seek(0)
		temp.close()

	# INSERT POSTS INTO PAGE
	for i in range(len(page)):
		page[i] = page[i].replace("[[posts]]", "\n\n".join(posts))

	# WRITE PAGE TO OUTPUT HTML FILE
	final = open("output/final.html", "a+")
	final.write("".join(page))

	# CLOSE FILES
	base_html.close()
	post_html.close()

    def __init__(self, src_path, exclude=() ):
        post_list = []
        
        for file_path in os.listdir(src_path):
            if not file_path.endswith('.py') or file_path in SOURCE_EXCLUDE:
                # TODO convert to regex matching
                continue
            full_path = os.path.join(src_path, file_path)
            try:
                post = Post(full_path)
                post_list.append(post)
            except Exception as e:
                import traceback
                traceback.print_exc()
                print 'Error creating Post from '+str(full_path)+':'+str(e)
                continue

        self.posts = sorted(post_list, key=lambda p: p.updated)

        self._check_monotonic()
        self._resolve_links()
        
        for post in self.posts:
            errors = post.get_errors()
            for error in errors:
                print 'Error in',post.filename,'on line',str(error.line)+': ',error.message,
                if error.text: print '('+error.text+')'
                print

 def receive(self, message):
     post = Post()
     html_bodies = message.bodies('text/html')
     img_links = []
     video_links = []
     for content_type, body in html_bodies:
         decoded_body = body.decode()
         img_links.extend(self.find_image_links(decoded_body))
         video_links.extend(self.find_video_links(decoded_body))
 
     if hasattr(message, "attachments") and message.attachments:
         post.attachments = []
         for attachment in message.attachments:
             post.attachments.append(db.Blob(attachment[1].decode()))
 
     plaintext_bodies = message.bodies('text/plain')
     allBodies = '';
     for body in plaintext_bodies:
         allBodies = allBodies + body[1].decode()
 
     if hasattr(message, "subject"):
         subject, encoding = decode_header(message.subject)[0]
         post.caption = unicode(subject)
     post.author = message.sender
     post.content = allBodies
     post.images = img_links
     post.videos = video_links
     post.source = "email"
     post.put()

def publish(post_meta):


    doc_id = Post.url_friendly_text(post_meta["title"])
    
    # Open the database
    couch = couchdb.Server()
    db = couch["mrvoxel_blog"]
    
    # Load the database settings
    blog_settings = settings.loadSettings(db)
    
    # Check to see if we have a valid category
    if not post_meta["category"] in blog_settings["blog_categories"]:
        raise ValueError("No such category: %s" % post_meta["category"])
    
    print "checking for [%s]" % doc_id
    
    # Load the post (if it exists in our database)
    post = Post.load(db, doc_id)
    
    # If it exists, warn the user
    if post:
        raw = raw_input("This will replace an existing post of the same title...\nContinue? (y/N)")
        
        # if the existing post is published but we're trying to preview
        if (post["published"] == False) and post_meta["published"]:
            raise ValueError("Cannot yet preview posts that are already published")
        
        if raw != "y":
            print "Canceling publish."
            return None
        else:
            for k, v in post_meta.iteritems():
                if k not in ["published", "title"]:
                    print k
                    post[k] = v
            
            print post
            
            """
            post.markdown = mdtext
            post.html = html
            post.author = author
            post.timestamp = timestamp
            post.published = not preview
            post.title = title
            post.tags = tags
            post.category = category
            """
            
            post.store(db)
    else:
        
        post = Post.create(**post_meta)
        print post["_id"]
        post.store(db)
        print post["_id"]
    return post["_id"]

 def new_post(self, title, content, date=datetime.datetime.utcnow()):
     post = Post(blog_id=self._id,
                 title=title,
                 content=content,
                 author=self.author,
                 # formats the date string object into datetime
                 date=date)
     post.save_to_mongo()

 def load_post(self):
     """ load post
     """
     for post_source in glob.glob(self.post_path + self.post_pattern):
         post = Post()
         post.load_from_file(post_source)
         # self.posts.append(post)
         self.post_mapping[post.link] = post

 def post(self):
     user = users.get_current_user()
     
     if user:
         post = Post(parent = Post.post_db_key(), author = user, content = self.request.get("content"))
         post.put()
     
     self.redirect('/')

def mod_post(args):
    posts = Post.load()
    if not args.title and not args.body:
        print('Either title or body are required for post modificaion')
    else:
        p = Post(args.title or posts[args.postid]['title'],
                 args.body or posts[args.postid]['body'],
                 postid=args.postid)
        p.save()

    def render_latest_posts(self, limit):
        accu = ''
        for post_path in self.latest_posts(limit):
            post = Post(post_path)
            accu += post.render("short-post")

        output = open(os.path.join(
            self.__render_base_path, "latest_posts.rst"), "w", encoding='utf-8')
        output.write(accu)
        output.close()

    def render_latest_posts(self, limit):
        accu = ''
        for post_path in self.latest_posts(limit):
            post = Post(post_path)
            accu += post.render('short-post')

        output = open(os.path.join(
            self.__render_base_path, 'latest_posts.rst'), 'w')
        output.write(accu)
        output.close()

    def get(self):
        post_id = self.request.get('post_id')
        user_id = self.user.key().id()

        if user_id and post_id and not LikePostRelation.check_like_status(user_id,post_id):
            Post.updateLike(post_id)
            like_post_relation = LikePostRelation.create_like_post_relation(user_id,post_id)
            like_post_relation.put()

        self.redirect('/blog/%s' % post_id)

    def get_post(self, post_id):
        post = self.loaded_posts.get(post_id, None)
        if post is None:
            path = u"{0}/{1}.md".format(self.working_dir, post_id)
            if os.path.exists(path):
                post = Post(post_id, working_dir=self.working_dir)
                self.loaded_posts[post_id] = post
        else:
            post.refresh()

        return post

    def post(self):
        user = users.get_current_user()
        if not user or not users.is_current_user_admin():
            self.redirect(users.create_login_url(self.request.uri))
            return

        post = Post()
        post.title = self.request.POST['title']
        post.put()

        self.redirect('/admin/posts/edit/' + str(post.key.id()))

 def get(self, post_id=None, action=None):
     if action is None:
         posts = Post.all()
         self.response.out.write(helper.render('admin/posts', { 'posts': posts }))
     elif action == "delete":
         Post.get_by_id(int(post_id)).delete()
         return self.redirect('/admin/posts')
     elif action == "confirm":
         post = Post.get_by_id(int(post_id))
         post.confirmed_at = datetime.datetime.today()
         post.put()
         return self.redirect('/admin/posts')

def post(arg):
    """defines post command"""

    postTypes = ["text", "photo", "quote", "link", "chat", "audio", "video"]
    postStates = ["published", "draft", "queue", "private"]

    args = arg.split(" ")

    if args[0] in postTypes:
        if args[0] == "text":
            if '"' in args[1]:
                quote_text = re.findall('"([^"]*)"', arg)
                text = ""

                if len(quote_text) > 1:
                    text = quote_text[0]

                text_post = {"title": "", "state": "", "blog": "", "tags": []}

                if "--title" in args:
                    if len(quote_text) == 1:
                        text_post['title'] = quote_text[0]
                    else:
                        text_post['title'] = quote_text[1]

                if "-s" in args:
                    state = args[args.index('-s') + 1]
                    if state in postStates:
                        text_post['state'] = state
                    else:
                        print "Invalid state value found: " + state
                        print "Posting now"

                if "-b" in args:
                    text_post['blog'] = args[args.index('-b') + 1]
                else:
                    text_post['blog'] = USERNAME

                if "-t" in args:
                    for s in args[args.index("-t") + 1:]:
                        if s not in ["--title", "-b", "-s"]:
                            text_post['tags'].append(s)
                        else:
                            break

                print text_post
                newPost = Post(client, text_post['blog'], "text", text_post['tags'])
                newPost.publish(text_post['state'], title=text_post['title'], body=text)

            else:
                print "No text content found! Text must be in quotes."
    else:
        print "Invalid post type: " + args[0]

    def run(self):
        while 1 == 1:
            try:
                for url in self.urls:
                    self.urls.remove(url)
                    print(url)

                    opener = urllib2.build_opener()
                    opener.addheaders = [('User-agent', 'Mozilla/5.0 (compatible; Googlebot/2.1; +http://www.google.com/bot.html)')]
                    response = opener.open(url)

                    html = response.read()
                    soup = BeautifulSoup(html, 'html.parser')
                    text = soup.text
                    links = soup.find_all('a')
                    images = soup.find_all('img')

                    post = Post(self.connection, url, url, 'url')
                    post.save()

                    download_path = 'sites/' + url
                    if not os.path.exists(download_path):
                        os.makedirs(download_path)

                    for image in images:
                        print('image')
                        src = urljoin(url, image.get('src'))
                        if src.startswith("http") or src.startswith("https"):
                                fname = self.basename(src)
                                if fname != None:
                                    self.download_file(src, download_path + fname)

                    print('ok')

                    '''self.reset_config()
                    for p in self.config:
                        textElements = re.findall(p['regex'], text)

                        if textElements != None:
                            for element in textElements:
                                post = Post(self.connection, element, element, p['type'])
                                post.save()'''
                    
                    for link in links:
                        href = urljoin(url, link.get('href'))
                        if href.startswith("http") or href.startswith("https"):
                            fname = self.basename(href)
                            if fname in self.extensions:
                                self.download_file(href, download_path + fname)
                            self.urls.append(href)
            except:
                pass

    def post(self,post_id):

        if not self.user:
            self.redirect('/blog/%s' % post_id)

        subject = self.request.get('subject')
        content = self.request.get('content')
        user_id = self.user.key().id()
        last_modified = datetime.datetime.now()
        post = Post.by_id(post_id)
        if post and post.created_by == user_id:
           Post.update(post_id,subject,content,last_modified)
        self.redirect('/blog/%s' % post_id)

def create_post_with_bugs(data, cur, bugs=None):
    post = Post(data)
    if bugs != None:
        post.populatebugs(bugs)
    else:
        cur.execute('''SELECT titles.title, bug.bugid, bug.status
                       FROM bugtitles AS titles, postbugs AS bug
                       WHERE bug.userid = ?
                         AND bug.postdate = ?
                         AND bug.bugid = titles.bugid''',
                    (post.userid, post.postdate.toordinal()))
        post.populatebugs([Bug(title, id, statusnum) for title, id, statusnum in cur.fetchall()])
    return post