예제 #1
0
    def GET(self,tags=None):
        try:
            all=self.param('all')
        except:
            all=False

        if(all):
            entries = Entry.all().order('-date')
            filename='micolog.%s.xml'%datetime.now().strftime('%Y-%m-%d')
        else:
            str_date_begin=self.param('date_begin')
            str_date_end=self.param('date_end')
            try:
                date_begin=datetime.strptime(str_date_begin,"%Y-%m-%d")
                date_end=datetime.strptime(str_date_end,"%Y-%m-%d")
                entries = Entry.all().filter('date >=',date_begin).filter('date <',date_end).order('-date')
                filename='micolog.%s.%s.xml'%(str(str_date_begin),str(str_date_end))
            except:
                self.render2('views/admin/404.html')

        cates=Category.all()
        tags=Tag.all()

        self.response.headers['Content-Type'] = 'binary/octet-stream'#'application/atom+xml'
        self.response.headers['Content-Disposition'] = 'attachment; filename=%s'%filename
        self.render2('views/wordpress.xml',{'entries':entries,'cates':cates,'tags':tags})
예제 #2
0
    def get(self):

        item_type = self.request.get('item')
        if item_type == "entry":
            object_list = Entry.all()
        elif item_type == "country":
            object_list = Country.all()
        else:
            item_type = None
            object_list = Entry.all()

        object_list = object_list.order('-publish_date')
        if users.get_current_user():
            url = users.create_logout_url(self.request.uri)
            url_linktext = 'Logout'
        else:
            url = users.create_login_url(self.request.uri)
            url_linktext = 'Login'

        template_values = {
            'object_list': object_list,
            'item_type': item_type,
            'url': url,
            'url_linktext': url_linktext,
        }

        path = os.path.join(os.path.dirname(__file__),
                            'templates/admin/view.html')
        self.response.out.write(template.render(path, template_values))
예제 #3
0
    def get(self):

        item_type = self.request.get('item')
        if item_type == "entry":
            object_list = Entry.all()
        elif item_type == "country":
            object_list = Country.all()
        else:
            item_type = None
            object_list = Entry.all()

        object_list = object_list.order('-publish_date')
        if users.get_current_user():
            url = users.create_logout_url(self.request.uri)
            url_linktext = 'Logout'
        else:
            url = users.create_login_url(self.request.uri)
            url_linktext = 'Login'

        template_values = {
            'object_list': object_list,
            'item_type': item_type,
            'url': url,
            'url_linktext': url_linktext,
        }

        path = os.path.join(os.path.dirname(__file__), 'templates/admin/view.html')
        self.response.out.write(template.render(path, template_values))
예제 #4
0
    def GET(self,slug=None,postid=None):
        if postid:
            postid = int(postid)
            entries = Entry.all().filter(published = True).filter(post_id = postid)[0:1]#.fetch(1)
        else:
            slug=urldecode(slug)
            entries = Entry.all().filter(published = True).filter(link = slug)[0:1]#.fetch(1)
        if not entries or len(entries) == 0:
            self.error(404)
            return

        mp=self.paramint("mp",1)

        entry=entries[0]
        if entry.is_external_page:
            self.redirect(entry.external_page_address,True)
        if self.blog.allow_pingback and entry.allow_trackback:
            self.response.headers['X-Pingback']="%s/rpc"%str(self.blog.baseurl)
        entry.readtimes += 1
        entry.put()
        self.entry=entry


        comments=entry.get_comments_by_page(mp,self.blog.comments_per_page)


##        commentuser=self.request.cookies.get('comment_user', '')
##        if commentuser:
##            commentuser=commentuser.split('#@#')
##        else:
        commentuser=['','','']

        comments_nav=self.get_comments_nav(mp,entry.purecomments().count())

        if entry.entrytype=='post':
            self.render('single',
                        {
                        'entry':entry,
                        'relateposts':entry.relateposts,
                        'comments':comments,
                        'user_name':commentuser[0],
                        'user_email':commentuser[1],
                        'user_url':commentuser[2],
                        'checknum1':random.randint(1,10),
                        'checknum2':random.randint(1,10),
                        'comments_nav':comments_nav,
                        })

        else:
            self.render('page',
                        {'entry':entry,
                        'relateposts':entry.relateposts,
                        'comments':comments,
                        'user_name':commentuser[0],
                        'user_email':commentuser[1],
                        'user_url':commentuser[2],
                        'checknum1':random.randint(1,10),
                        'checknum2':random.randint(1,10),
                        'comments_nav':comments_nav,
                        })
예제 #5
0
    def doget(self,page):
        page=int(page)
        #entrycount=self.blog.postscount()
        entrycount=Entry.postscount()
        max_page = entrycount / self.blog.posts_per_page + ( entrycount % self.blog.posts_per_page and 1 or 0 )

        if page < 1 or page > max_page:
            return self.error(404)

        offset_start = (page-1) * self.blog.posts_per_page
        offset_end = offset_start + self.blog.posts_per_page
        entries = Entry.all().filter(entrytype = 'post').\
                filter(published = True).order_by('-date')[offset_start:offset_end]#.\
                #fetch(self.blog.posts_per_page, offset = (page-1) * self.blog.posts_per_page)
        #import pdb; pdb.set_trace()

        show_prev =entries and  (not (page == 1))
        #show_prev = True
        show_next =entries and  (not (page == max_page))
        #show_next = True
        #print page,max_page,self.blog.entrycount,self.blog.posts_per_page


        self.render('index',{'entries':entries,
                           'show_prev' : show_prev,
                        'show_next' : show_next,
                        'pageindex':page,
                        'ishome':True,
                        'pagecount':max_page,
                        'postscounts':entrycount
                            })
예제 #6
0
 def action_updatecomments(self):
     for entry in Entry.all():
         cnt=entry.comments().count()
         if cnt<>entry.commentcount:
             entry.commentcount=cnt
             entry.put()
     self.write(_('"All comments updated"'))
예제 #7
0
    def GET(self,tags=None):
        urls = []
        def addurl(loc,lastmod=None,changefreq=None,priority=None):
            url_info = {
                'location':   loc,
                'lastmod':    lastmod,
                'changefreq': changefreq,
                'priority':   priority
            }
            urls.append(url_info)

        addurl(self.blog.baseurl,changefreq='daily',priority=0.9 )

        entries = Entry.all().filter(published = True).order_by('-date')[0:self.blog.sitemap_entries]#.fetch(self.blog.sitemap_entries)

        for item in entries:
            loc = "%s/%s" % (self.blog.baseurl, item.link)
            addurl(loc,item.mod_date or item.date,'never',0.6)

        if self.blog.sitemap_include_category:
            cats=Category.all()
            for cat in cats:
                loc="%s/category/%s"%(self.blog.baseurl,cat.slug)
                addurl(loc,None,'weekly',0.5)

        if self.blog.sitemap_include_tag:
            tags=Tag.all()
            for tag in tags:
                loc="%s/tag/%s"%(self.blog.baseurl, urlencode(tag.tag))
                addurl(loc,None,'weekly',0.5)


##        self.response.headers['Content-Type'] = 'application/atom+xml'
        self.render('/admin/views/sitemap.xml', {'urlset':urls}, content_type='text/xml')#, content_type='application/xhtml+xml')
예제 #8
0
 def GET(self,tags=None):
     entries = Entry.all().filter(entrytype = 'post').filter(published = True).order_by('-date')[0:10]#.fetch(10)
     if entries and entries[0]:
         last_updated = entries[0].date
         last_updated = last_updated.strftime("%a, %d %b %Y %H:%M:%S +0000")
     for e in entries:
         e.formatted_date = e.date.strftime("%a, %d %b %Y %H:%M:%S +0000")
     self.response.headers['Content-Type'] = 'application/rss+xml; charset=utf-8'
     self.render2('/admin/views/rss.xml',{'entries':entries,'last_updated':last_updated})
예제 #9
0
    def action_init_blog(self,slug=None):

        for com in Comment.all():
            com.delete()

        for entry in Entry.all():
            entry.delete()

        self.blog.entrycount=0
        self.blog.save()
        self.write(_('"Init has succeed."'))
예제 #10
0
def clean_gae():
    query = Entry.all()
    entries = query.fetch(1000)
    db.delete(entries)

    query = Country.all()
    countries = query.fetch(1000)
    db.delete(countries)

    query = Tag.all()
    tags = query.fetch(1000)
    db.delete(tags)
예제 #11
0
    def GET(self):
        #super(MainPage, self).initialize(request)
        params = {}
        page = 1
        entries = Entry.all().filter('entrytype =','post').\
    				filter("published =", True).order('-date').\
    				fetch(self.blog.posts_per_page, offset = (page-1) * self.blog.posts_per_page)
        for entry in entries:
            entry.link = '%s/%s' % (self.app_context.current_app, entry.link)

        params['entries'] = entries
        return self.render('index.html', params)
예제 #12
0
def clean_gae():
   query = Entry.all()
   entries =query.fetch(1000)
   db.delete(entries)

   query = Country.all()
   countries = query.fetch(1000)
   db.delete(countries)

   query = Tag.all()
   tags = query.fetch(1000)
   db.delete(tags)
예제 #13
0
    def action_update_tags(self,slug=None):
        for tag in Tag.all():
            tag.delete()
        for entry in Entry.all().filter('entrytype =','post'):
            if entry.tags:
                for t in entry.tags:
                    try:
                        Tag.add(t)
                    except:
                        traceback.print_exc()

        self.write(_('"All tags for entry have been updated."'))
예제 #14
0
    def GET(self,slug=None):
        if not slug:
             self.error(404)
             return
        try:
            page_index=int (self.param('page'))
        except:
            page_index=1
        import urllib
        slug=urldecode(slug)

        entries=Entry.all().filter(published = True).filter(tags = slug).order_by("-date")
        entries,links=Pager(query=entries,items_per_page=20).fetch(page_index)
        self.render('tag',{'entries':entries,'tag':slug,'pager':links})
예제 #15
0
 def initialize(self, request):
     m_pages=Entry.all().filter('entrytype =','page')\
         .filter('published =',True)\
         .filter('entry_parent =',0)\
         .order('menu_order')
     blogroll=Link.all().filter('linktype =','blogroll')
     archives=Archive.all().order('-year').order('-month').fetch(12)
     alltags=Tag.all()
     self.template_vals.update({
                     'menu_pages':m_pages,
                     'categories':Category.all(),
                     'blogroll':blogroll,
                     'archives':archives,
                     'alltags':alltags,
                     'recent_comments':Comment.all().order('-date').fetch(5)
     })
예제 #16
0
    def GET(self,slug=None):
        if not slug:
             self.error(404)
             return
        try:
            page_index=int(self.param('page'))
        except:
            page_index=1
        slug=urldecode(slug)

        cats=Category.all().filter(slug = slug)[0:1]#.fetch(1)
        if cats:
            entries=Entry.all().filter(published = True).filter(categorie_keys = cats[0].key()).order_by("-date")
            entries,links=Pager(query=entries,items_per_page=20).fetch(page_index)
            self.render('category',{'entries':entries,'category':cats[0],'pager':links})
        else:
            self.error(404,slug)
예제 #17
0
 def initialize(self, request):
     BaseRequestHandler.initialize(self,request)
     m_pages=Entry.all().filter(entrytype = 'page') \
         .filter(published = True)\
         .filter(entry_parent = 0)\
         .order_by('menu_order')
     blogroll=Link.all().filter(linktype = 'blogroll')
     #archives=Archive.all().order_by('-year').order_by('-month').fetch(12)
     archives=Archive.all().order_by('-year', '-month')[0:12]
     alltags=Tag.all()
     self.template_vals.update({
                     'menu_pages':m_pages,
                     'categories':Category.all(),
                     'blogroll':blogroll,
                     'archives':archives,
                     'alltags':alltags,
                     'recent_comments':Comment.all().order_by('-date')[0:5]#.fetch(5)
     })
예제 #18
0
    def GET(self,slug='post'):
        try:
            page_index=int(self.param('page'))
        except:
            page_index=1




        entries=Entry.all().filter('entrytype =',slug).order('-date')
        entries,links=Pager(query=entries,items_per_page=15).fetch(page_index)

        self.render2('views/admin/'+slug+'s.html',
         {
           'current':slug+'s',
           'entries':entries,
           'pager':links
          }
        )
예제 #19
0
    def action_updatelink(self):
        link_format=self.param('linkfmt')

        if link_format:
            link_format=link_format.strip()
            self.blog.link_format=link_format
            self.blog.save()
            for entry in Entry.all():
                vals={'year':entry.date.year,'month':str(entry.date.month).zfill(2),'day':entry.date.day,
                'postname':entry.slug,'post_id':entry.post_id}

                if entry.slug:
                    newlink=link_format%vals
                else:
                    newlink=self.blog.default_link_format%vals

                if entry.link<>newlink:
                    entry.link=newlink
                    entry.put()
            self.write(_('"Link formated succeed"'))
        else:
            self.write(_('"Please input url format."'))
예제 #20
0
    def action_update_archives(self,slug=None):
        for archive in Archive.all():
            archive.delete()
        entries=Entry.all().filter('entrytype =','post')

        archives={}


        for entry in entries:
            my = entry.date.strftime('%B %Y') # September-2008
            sy = entry.date.strftime('%Y') #2008
            sm = entry.date.strftime('%m') #09
            if archives.has_key(my):
                archive=archives[my]
                archive.entrycount+=1
            else:
                archive = Archive(monthyear=my,year=sy,month=sm,entrycount=1)
                archives[my]=archive

        for ar in archives.values():
            ar.put()

        self.write(_('"All entries have been updated."'))
예제 #21
0
	def sticky_entrys(self):
		return Entry.all().filter('entrytype =','post')\
			.filter('published =',True)\
			.filter('sticky =',True)\
			.order('-date')
예제 #22
0
    def POST(self,slug=None,postid=None):
        '''handle trackback'''
        error = '''<?xml version="1.0" encoding="utf-8"?>
<response>
<error>1</error>
<message>%s</message>
</response>
'''
        success = '''<?xml version="1.0" encoding="utf-8"?>
<response>
<error>0</error>
</response>
'''

        if not self.blog.allow_trackback:
            self.response.out.write(error % "Trackback denied.")
            return
        self.response.headers['Content-Type'] = "text/xml"
        if postid:
            entries = Entry.all().filter(published = True).filter(post_id = postid)[0:1]#.fetch(1)
        else:
            slug=urldecode(slug)
            entries = Entry.all().filter(published = True).filter(link = slug)[0:1]#.fetch(1)

        if not entries or len(entries) == 0 :#or  (postid and not entries[0].link.endswith(self.blog.default_link_format%{'post_id':postid})):
            self.response.out.write(error % "empty slug/postid")
            return
        #check code ,rejest spam
        entry=entries[0]
        logging.info(self.request.remote_addr+self.request.path+" "+entry.trackbackurl)
        #key=self.param("code")
        #if (self.request.uri!=entry.trackbackurl) or entry.is_external_page or not entry.allow_trackback:
        #import cgi
        from urlparse import urlparse
        param=urlparse(self.request.uri)
        code=param[4]
        param=cgi.parse_qs(code)
        if param.has_key('code'):
            code=param['code'][0]

        if  (not str(entry.key())==code) or entry.is_external_page or not entry.allow_trackback:
            self.response.out.write(error % "Invalid trackback url.")
            return


        coming_url = self.param('url')
        blog_name = myfilter.do_filter(self.param('blog_name'))
        excerpt = myfilter.do_filter(self.param('excerpt'))
        title = myfilter.do_filter(self.param('title'))

        if not coming_url or not blog_name or not excerpt or not title:
            self.response.out.write(error % "not enough post info")
            return

        import time
        #wait for half second in case otherside hasn't been published
        time.sleep(0.5)

##        #also checking the coming url is valid and contains our link
##        #this is not standard trackback behavior
##        try:
##
##            result = urlfetch.fetch(coming_url)
##            if result.status_code != 200 :
##                #or ((self.blog.baseurl + '/' + slug) not in result.content.decode('ascii','ignore')):
##                self.response.out.write(error % "probably spam")
##                return
##        except Exception, e:
##            logging.info("urlfetch error")
##            self.response.out.write(error % "urlfetch error")
##            return

        comment = Comment.all().filter(entry = entry).filter(weburl = coming_url).get()
        if comment:
            self.response.out.write(error % "has pinged before")
            return

        comment=Comment(author=blog_name,
                content="...<strong>"+title[:250]+"</strong> " +
                        excerpt[:250] + '...',
                weburl=coming_url,
                entry=entry)

        comment.ip=self.request.remote_addr
        comment.ctype=COMMENT_TRACKBACK
        try:
            comment.save()

            memcache.delete("/"+entry.link)
            self.write(success)
            self.blog.tigger_action("pingback_post",comment)
        except:
            self.response.out.write(error % "unknow error")
예제 #23
0
파일: views.py 프로젝트: rmalik/dspillini
def home(request):
	entries = Entry.all()
	entries.order('-published')
	entries.fetch(limit=5)
	events = fetch_events()
	return render_to_response('home.html', {'events': events[0:5], 'entries':entries})
예제 #24
0
 def action_updatecommentno(self):
     for entry in Entry.all():
         entry.update_commentno()
     self.write(_('"All comments number Updates."'))
예제 #25
0
 def sticky_entrys(self):
     return Entry.all().filter(entrytype = 'post')\
         .filter(published = True)\
         .filter(sticky = True)\
         .order_by('-date')
예제 #26
0
 def items(self):
     return Entry.all()
예제 #27
0
파일: views.py 프로젝트: rmalik/dspillini
def archive_index(request):
	entries = Entry.all()
	entries.order('-published')
	entries.fetch(limit=5)
	return render_to_response('base.html')#, {'entries': entries, 'events': events})
예제 #28
0
파일: views.py 프로젝트: directeur/socnode
def show_entry(request, key):
    return object_detail(request, Entry.all(), key)