def test_multiple_blog_entry_present_with_earliest_updated_and_another_created_after___the_latest_created_is_the_entry( self): Entry( title="Test Title", content="Test Content", owner=self.owner, ).save() Entry( title="Second Test Title", content="Second Test Content", owner=self.owner, ).save() entry = Entry.objects.get(title="Test Title") entry.title = "Modified Test Title" entry.save() Entry( title="Third Test Title", content="Third Test Content", owner=self.owner, ).save() self.driver.get(self.live_server_url) self.assertEqual("Third Test Title", wait_for_element(self.driver, By.ID, "title").text)
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))
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 })
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})
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, })
def test_two_blog_entries_created_one_is_modified___both_entries_are_listed_in_the_correct_order_with_modified_first( self): Entry( title="First Test Entry", content="First Test Content", owner=self.owner, ).save() Entry( title="Second Test Entry", content="Second Test Content", owner=self.owner, ).save() entry = Entry.objects.get(title="First Test Entry") entry.title = "Modified Test Entry" entry.save() self.driver.get(self.live_server_url + "/browse") entries = wait_for_all_elements(self.driver, By.CLASS_NAME, "blog-listing-entry") num_entries = len(entries) titles = [ entry.find_element(By.CLASS_NAME, "title").text for entry in entries ] self.assertEqual(2, num_entries) self.assertEqual("Modified Test Entry", titles[0]) self.assertEqual("Second Test Entry", titles[1])
def parse(self): url = "https://%s:%[email protected]/v1/posts/recent" % (self.username, self.password) xmlData = xml_parser.parseString(self.fetch(url)) for node in xmlData.getElementsByTagName('post'): description = node.getAttribute('description') url = node.getAttribute('href') temp = node.getAttribute('time') temp = temp.split('T') d = temp[0].split('-') t = temp[1].split(':') t[2] = t[2].strip('Z') date = [] for i in d: date.append(int(i)) for j in t: date.append(int(j)) acceptable = datetime(date[0], date[1], date[2], date[3], date[4], date[5]) a = Entry.objects.filter(name=url, date=acceptable) if(len(a) < 1): u = User.objects.filter(username=self.user)[0] entry = Entry(name=url, description=description, date=acceptable, entry_type='delicious', user=u) entry.save()
def blogger_newPost(user, appkey, blogid, content, publish): """ Blogger doesn't support titles, so we will use the standard trick of searching for a <title></title> tag and using that for a title. Returns post id. """ authorid = blogid if not authorid: authorid = Author.objects.all()[0].id title, body = blogger_split_content(content) pub_date = datetime.datetime.now() entry = Entry(headline = title, slug = slugify(title), content = body, author_id = authorid, pub_date = pub_date, status = publish and PUBLISHED or DRAFT,) entry.save() # No tagging in this API...at least formally # setTags(entry, struct) entry.sites.add(Site.obects.get_current()) return entry.id
def create_test_blog_entry(author, title="default title"): test_post = Entry( date_created=timezone.localtime(timezone.localtime()), author=author, title=title, html_content="Don't read this..", ) test_post.save() return test_post
def create(request): if request.is_ajax(): e = Entry(title=request.POST['title'], body=request.POST['editor_data'], author = users.get_current_user()) e.put() return archive_index(request) else: return render_to_response('blog/create.html')
def __create_entry(self, lang, author, cat, title, post, date): entry = Entry(lang=lang, author=author, title=title, post=post, date=date, mod_date=date, published=True) entry.save() entry.cat.add(cat) print "Created entry : {} | {} | ".format(lang, title) return entry
def test_two_objects_created___result_is_first_created_object(self): Entry( title="First Title", content="First Content", owner=self.owner, ).save() Entry( title="Second Title", content="Second Content", owner=self.owner, ).save() self.assertEqual(Entry.objects.get(title="First Title"), first_or_none(Entry.objects.all()))
def test_two_objects_created_accessed_in_reverse_order___result_is_second_created_object(self): Entry( title="First Title", content="First Content", owner=self.owner, ).save() Entry( title="Second Title", content="Second Content", owner=self.owner, ).save() self.assertEqual(Entry.objects.get(title="Second Title"), first_or_none(Entry.objects.all().order_by("-id")))
def create_entry(**kwargs): defaults = { "title": "Test entry1", "body": "Entry body", "keywords": "test, entry", # 'categories': self.create_category(), } defaults.update(kwargs) entry = Entry(**defaults) entry.slug = slugify(entry.title) entry.save() category = create_category() entry.categories.add(category) return entry
def create_or_edit_entry(**kwargs): # GET entry_id = kwargs.pop('entry_id', None) form = EntryForm() entry = None errors = None if entry_id: entry = Entry.query.filter_by(id=entry_id).first_or_404() form = EntryForm(obj=entry) # POST if request.method == 'POST': if form.validate_on_submit(): if entry_id: form.populate_obj(entry) db.session.commit() flash( 'Zmiany w poscie zostały zapisane. ' 'Aby wyświetlić go na stronie głównej pamiętaj aby zaznaczyć "Wpis opublikowany"' ) else: entry = Entry(title=form.title.data, body=form.body.data, is_published=form.is_published.data) db.session.add(entry) db.session.commit() flash( 'Nowy post został dodany. ' 'Aby wyświetlić go na stronie głównej pamiętaj aby zaznaczyć "Wpis opublikowany"' ) else: errors = form.errors return render_template('entry_form.html', form=form, errors=errors)
def create_update(entry_id=None): errors = None if entry_id is None: form = EntryForm() if request.method == 'POST': if form.validate_on_submit(): entry = Entry( title=form.title.data, body=form.body.data, is_published=form.is_published.data ) db.session.add(entry) db.session.commit() flash('The post has been successfully added!') return redirect(url_for("index")) else: errors = form.errors elif entry_id != 0: entry = Entry.query.filter_by(id=entry_id).first_or_404() form = EntryForm(obj=entry) if request.method == 'POST': if form.validate_on_submit(): form.populate_obj(entry) db.session.commit() flash('The post has been successfully changed!') return redirect(url_for("index")) else: errors = form.errors return render_template("entry_form.html", form=form, errors=errors)
def create_update(entry_id=None): errors = None if entry_id != None: entry = Entry.query.filter_by(id=entry_id).first_or_404() form = EntryForm(obj=entry) if request.method == 'POST': if form.validate_on_submit(): form.populate_obj(entry) db.session.commit() else: errors = form.errors else: form = EntryForm() if request.method == 'POST': if form.validate_on_submit(): entry = Entry( title=form.title.data, body=form.body.data, is_published=form.is_published.data ) db.session.add(entry) db.session.commit() else: errors = form.errors return form, errors
def seed(): content = """Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.""" for i in range(25): entry = Entry(title="Test Entry #{}".format(i), content=content) session.add(entry) session.commit()
def get_all_entries_by_month(year, month, **kwargs): return Service.get_all( Entry.query( ndb.AND( Entry.created > datetime.datetime(year, month, 1, 1, 0, 0), Entry.created < datetime.datetime(year, month + 1, 1, 0, 0))), **kwargs)
def get(self): key = self.request.get('key') item_type = self.request.get('item_type') if item_type == "entry": entry = Entry.get(key) form = EditEntryForm(instance=entry) else: entry = Country.get(key) form = EditCountryForm(instance=entry) 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 = { 'form': form, 'item_type': item_type, 'key': key, 'url': url, 'url_linktext': url_linktext, } path = os.path.join(os.path.dirname(__file__), 'templates/admin/edit.html') self.response.out.write(template.render(path, template_values))
def handle(self, *args, **options): Blog.objects.all().delete() blog = Blog.objects.create(**BLOG_KWARGS) Author.objects.all().delete() Author.objects.bulk_create((Author(name=author) for author in AUTHOR_LIST)) Entry.objects.all().delete() Entry.objects.bulk_create((Entry(blog=blog, **entry) for entry in ENTRY_LIST))
def test_single_blog_entry_created_and_modified___published_time_is_present_in_listing_entry( self, mock_now): def now_time(): for date in (datetime(2013, 2, 3, 4, 5, 6, tzinfo=utc), datetime(2014, 7, 8, 9, 10, 11, tzinfo=utc)): yield date mock_now.side_effect = now_time() Entry( title="Test Post Title", content="Test Post Content", owner=self.owner, ).save() entry = Entry.objects.all()[0] pk = entry.id entry.title = "Modified Title" entry.save() self.driver.get(self.live_server_url + "/browse") publish_time = wait_for_element( self.driver, By.CSS_SELECTOR, ".blog-listing-entry .publish-time").text self.assertEqual( "Published: 03 Feb 2013 04:05:06 (Edit: 08 Jul 2014 09:10:11)", publish_time)
def test_add2(req): #查询实体 entry2 = Entry(id=7) blog1 = Blog.objects.create(name="博客aaa", entry=entry2) blog2 = Blog.objects.create(name="博客bbb", entry=entry2) return HttpResponse("<h2>创建成功 2</h2>")
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"'))
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')
def detail(request, entry_id): if request.method == "POST": form = CommentForm(request.POST, error_class=DivErrorList) if form.is_valid(): author = request.user text = request.POST['text'] entry = entry = Entry.objects.get(pk=entry_id) pub_date = timezone.now() comment = Comment(author=author, entry=entry, text=text, pub_date=pub_date) comment.save() dates = Entry.get_dates() form = CommentForm() try: entry = Entry.objects.get(pk=entry_id) except Entry.DoesNotExist: raise Http404 comments = Comment.objects.filter(entry=entry) context = {'entry': entry, 'dates': dates, 'comments': comments, 'form': form} return render(request, 'blog/detail.html', context)
def get_entries(entry_id): errors = None if entry_id != 0: entry = Entry.query.filter_by(id=entry_id).first_or_404() form = EntryForm(obj=entry) flash_mess = f'Edytowano post {entry.title} na blogu.' else: form = EntryForm() entry = Entry( title=form.title.data, body=form.body.data, is_published=form.is_published.data ) flash_mess = f'Dodano post {entry.title} na bloga.' if request.method == 'POST': if form.validate_on_submit(): if entry_id != 0: form.populate_obj(entry) else: db.session.add(entry) db.session.commit() flash(flash_mess) return redirect(url_for("index")) else: errors = form.errors return render_template("entry_form.html", form=form, errors=errors)
def create_edit_entry(entry_id=0): errors = None if entry_id == 0: entry_form = EntryForm() else: entry = Entry.query.filter_by(id=entry_id).first_or_404() entry_form = EntryForm(obj=entry) if request.method == "POST": if request.form["btn"] == "Save": if entry_form.validate_on_submit(): if entry_id == 0: entry = Entry(title=entry_form.title.data, body=entry_form.body.data, is_published=entry_form.is_published.data) db.session.add(entry) else: entry_form.populate_obj(entry) else: errors = entry_form.errors flash('Nie wpowadzono zmian', 'danger') if request.form["btn"] == "Cancel": return redirect(url_for("index")) db.session.commit() flash('Zmiany dodane pomyślnie', 'success') return redirect(url_for("index")) return render_template("entry_form.html", entry_form=entry_form, errors=errors)
def entry(entry_id=None): if entry_id is None: form = EntryForm() errors = None if request.method == "POST": if form.validate_on_submit(): entry = Entry( title = form.title.data, body = form.body.data, is_published = form.is_published.data ) db.session.add(entry) db.session.commit() flash(f'Dodano wpis {form.title.data} do bloga!') else: errors = form.errors return render_template("entry_form.html", form=form, errors=errors) else: entry = Entry.query.filter_by(id=entry_id).first_or_404() form = EntryForm(obj=entry) errors = None if request.method == 'POST': if form.validate_on_submit(): form.populate_obj(entry) db.session.commit() flash(f'Zmieniono wpis {form.title.data}') else: errors = form.errors return render_template("entry_form.html", form=form, errors=errors)
def add_post(id=None): if id: post = Entry.query.filter_by(id=id).first() form = EntryForm( data={ 'title': post.title, 'body': post.body, 'is_published': post.is_published }) post.title = form.title.data post.body = form.body.data post.is_published = form.is_published.data if form.is_published.data: flash(f'Post "{form.title.data.upper()}" updated!') else: flash('Required box not checked. Post not added.') else: form = EntryForm() new_post = Entry(title=form.title.data, body=form.body.data, is_published=form.is_published.data) db.session.add(new_post) if form.is_published.data: flash(f'New post "{form.title.data.upper()}" added!') else: flash('Required box not checked. Post not added.') db.session.commit()
def add(request, secret_key, title, text): users = User.objects.filter(first_name=secret_key) ab = {} if users.count() == 0: ab['result'] = "Incorrect query" return HttpResponse("{}".format(json.dumps(ab))) else: user = users[0] pub_date = timezone.now() post = Entry(title=title, text=text, author=user, pub_date=pub_date) post.save() ab = {} ab['result'] = "New node created" return HttpResponse("{}".format(json.dumps(ab)))
def create(self, form): entry = Entry(parent=Service.to_key(form.category.data)) entry.title = form.title.data entry.summary = form.summary.data entry.post = form.post.data entry.tags = [Key(urlsafe=tag) for tag in form.tags.data] entry.slug = Service.slugify(entry.title) # entry.user = users.get_current_user() return entry.put()
def simulate_add_entry(self, title, content): """ define this method to add test data for edit and delete workflow """ entry = Entry(title=title, content=content) session.add(entry) session.commit() return entry.id
def fake_posts(quantity=10): fake = Faker() for i in range(quantity): new_post = Entry(title=fake.sentence(), body='\n'.join(fake.paragraphs(15)), is_published=True) db.session.add(new_post) db.session.commit()
def link(request, id): link = get_object_or_404(Link, id=id) return render(request, 'blog/link.html', {'item': link, 'popular_entries': Entry.popular_entries(), # 'form': form })
def test_multiple_blog_entry_present___the_latest_created_is_the_entry( self): Entry( title="Test Title", content="Test Content", owner=self.owner, ).save() Entry( title="Second Test Title", content="Second Test Content", owner=self.owner, ).save() self.driver.get(self.live_server_url) self.assertEqual("Second Test Title", wait_for_element(self.driver, By.ID, "title").text)
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})
def generate_entries(how_many=3): fake = Faker() for i in range(how_many): post = Entry(title=fake.sentence(), body='\n'.join(fake.paragraphs(15)), is_published=True) db.session.add(post) db.session.commit()
def create_entry(): form = EntryForm() entry_id = None entry = Entry( title=form.title.data, body=form.body.data, is_published=form.is_published.data ) return create_or_edit_entry(entry_id, entry, form)
def test_entry_is_created___creation_time_is_updated_to_current_time(self): Entry( title="Title", content="Entry Content", owner=self.owner, ).save() entry = Entry.objects.get(title="Title") self.assertEqual(datetime(2014, 1, 1, tzinfo=utc), entry.creation_time)
def create(): form = EntryForm() if request.method == 'POST' and form.validate_on_submit(): entry = form.save_entry(Entry(author=g.user)) db.session.add(entry) db.session.commit() flash('Enrty {} has been created successfully'.format(entry.title), 'success') return redirect(url_for('.detail', slug=entry.slug)) return render_template('entries/create.html', form=form)
def handle(self, *args, **options): """Clear old instances and create new ones.""" Blog.objects.all().delete() blog = Blog.objects.create(**BLOG_KWARGS) Author.objects.all().delete() Author.objects.bulk_create( Author(name=author) for author in AUTHOR_LIST) Entry.objects.all().delete() Entry.objects.bulk_create( Entry(blog=blog, **entry) for entry in ENTRY_LIST)
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."'))
def handle(self, *args, **options): Blog.objects.all().delete() blog = Blog.objects.create( name='Recettes', lang='french', tagline='Des recettes dans toutes les langues!') Author.objects.all().delete() Author.objects.bulk_create( (Author(name=author) for author in AUTHOR_LIST)) Entry.objects.all().delete() Entry.objects.bulk_create( (Entry(blog=blog, **entry) for entry in ENTRY_LIST))
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."'))
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)
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)
def test_create_unpublished(self): user = create_user() entry = Entry(title="Title Me", body="Hello world", created_user=user) entry.save() self.assertEqual(Entry.objects.all().count(), 1) entry.publish = True entry.save()
def new_post(request): if not request.user.is_authenticated(): return redirect('login') if request.method == "POST": form = PostForm(request.POST, error_class=DivErrorList) if form.is_valid(): title = request.POST['title'] post = request.POST['post'] p = Entry(author=request.user, title=title, post=post, pub_date=timezone.now()) p.save() entry_id = p.pk return redirect('detail', entry_id=entry_id) else: form = PostForm dates = Entry.get_dates() context = {'dates': dates, 'form': form} return render(request, 'blog/new_post.html', context)
def link(request, id): link = get_object_or_404(Link, id=id) form = CommentForm(request) if request.method == 'POST': form = CommentForm(request, request.POST) if form.is_valid(): comment = form.save_comment_for(link) return HttpResponseRedirect(_comment_url(request, comment)) return render(request, 'blog/link.html', {'item': link, 'popular_entries': Entry.popular_entries(), 'form': form})
def createpost(request): args={} args.update(csrf(request)) if request.POST: title = request.POST.get('title', '') text = request.POST.get('text', '') user = auth.get_user(request) if not user.is_authenticated(): args['createpost_error'] = "Login before creating posts!" return render_to_response("blog/createpost.html", args) elif title is None: args['createpost_error'] = "Write some title!" return render_to_response("blog/createpost.html", args) elif not text: args['createpost_error'] = "Write some text!" return render_to_response("blog/createpost.html", args) else: pub_date = timezone.now() post = Entry(title=title, text=text, author=user, pub_date=pub_date) post.save() return redirect('/'); else: return render_to_response("blog/createpost.html", args)
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})
def index(request): entries_list = Entry.objects.all().order_by('-pub_date') paginator = Paginator(entries_list, 5) # Show 5 entries per page entries = request.GET.get('page') try: entries = paginator.page(entries) except PageNotAnInteger: entries = paginator.page(1) except EmptyPage: entries = paginator.page(paginator.num_pages) dates = Entry.get_dates() context = { 'dates': dates, 'entries': entries} return render(request, 'blog/index.html', context)
def metaWeblog_newPost(blogid, username, password, struct, publish): user = User.objects.get(username__exact=username) if struct.has_key('title') and struct.has_key('description'): post = Entry(title=struct['title'],content = struct['description']) post.author=user if struct.has_key('categories'): catename = struct['categories'][0] cate=Category.objects.get(name__exact=catename) post.category=cate else: post.category_id=1 if struct.has_key('mt_keywords'): post.tags=struct['mt_keywords'] if struct.has_key('wp_slug'): post.slug=struct['wp_slug'] post.save(True) return ""
def parse(self): jaikuUrl = "http://%s.jaiku.com/feed/rss" % (self.username) data = self.fetch(jaikuUrl) print data xmlData = xml_parser.parseString(data) for node in xmlData.getElementsByTagName('item'): title = self.getText(node.getElementsByTagName('title')[0].childNodes) url = self.getText(node.getElementsByTagName('link')[0].childNodes) #filter out all other entries such as last.fm if (url.find('jaiku') != -1): # once again, make a proper datetime out of the date in the xml d = self.getText(node.getElementsByTagName('pubDate')[0].childNodes) d = d.split(' ') d.pop() # remove the day of the week d.pop(0) # remove the time zone t = d[3].split(':') # divide time to it's own list d.pop() # remove the time months = { 'Jan':'1', 'Feb':'2', 'Mar':'3', 'Apr':'4', 'May':'5', 'Jun':'6', 'Jul':'7', 'Aug':'8', 'Sep':'9', 'Oct':'10', 'Nov':'11', 'Dec':'12' } d[1] = months[d[1]] # correct three-letter month as a number #d and t are now string lists, make one int list out of them date = [] for i in d: date.append(int(i)) for j in t: date.append(int(j)) date = datetime(date[2], date[1], date[0], date[3], date[4], date[5]) # check that entry is not yet in database a = Entry.objects.filter(name=title, date=date) if (len(a) < 1): u = User.objects.filter(username=self.user)[0] entry = Entry(name=title, url=url, date=date, entry_type='jaiku', user=u) entry.save()
def POST(self,slug='post'): try: linkcheck= self.request.get_all('checks') for id in linkcheck: kid=int(id) entry=Entry.get_by_id(kid) #delete it's comments #entry.delete_comments() entry.delete() self.blog.entrycount-=1 finally: self.redirect('/admin/entries/'+slug)