def add_page(request, category_name_slug):
try:
cat = Category.objects.get(slug=category_name_slug)
except Category.DoesNotExist:
cat = None
if request.method == 'POST':
form = PageForm(request.POST)
if form.is_valid():
if cat:
page = form.save(commit=False)
page.category = cat
page.views = 0
page.save()
return category(request, category_name_slug)
else:
print form.errors
else:
print form.errors
else:
form = PageForm()
context_dict = {'form':form, 'category':cat, 'slug':category_name_slug }
return render(request, 'add_page.html', context_dict)
def edit(request, name):
"""Allows users to edit wiki pages."""
try:
page = Page.objects.get(name=name)
except Page.DoesNotExist:
page = None
if request.method == 'POST':
form = PageForm(request.POST)
if form.is_valid():
if not page:
page = Page()
page.name = form.cleaned_data['name']
page.save()
revision = Revision()
revision.page = page
revision.content = form.cleaned_data['content']
if request.user.is_authenticated():
revision.editor = request.user
revision.save()
return HttpResponseRedirect(page.get_absolute_url())
else:
if page:
revision = page.get_latest_revision()
form = PageForm(initial={'name': page.name, 'content': revision.content})
else:
form = PageForm(initial={'name': name})
ctx = { 'form': form }
return render_to_response('wiki/edit.html', ctx, context_instance=RequestContext(request))
def add_page(request, category_name_slug):
try:
cat = Category.objects.get(slug=category_name_slug)
except Category.DoesNotExist:
cat = None
if request.method == 'POST':
form = PageForm(request.POST)
if form.is_valid():
if cat:
page = form.save(commit=False)
page.category = cat
page.views = 0
page.save()
# probably better to use a redirect here
return HttpResponseRedirect('/rango/')
# return category(request, category_name_slug)
else:
print form.errors
else:
form = PageForm()
context_dict = {'form': form, 'category': cat, 'category_name_slug': category_name_slug}
return render(request, 'rango/add_page.html', context_dict)
def edit(request, name):
"""Allows users to edit wiki pages."""
try:
page = Page.objects.get(name=name)
except Page.DoesNotExist:
page = None
if request.method == 'POST':
form = PageForm(request.POST)
if form.is_valid():
if not page:
page = Page()
page.name = form.cleaned_data['name']
page.content = form.cleaned_data['content']
page.save()
return HttpResponseRedirect('../../%s/' % page.name)
else:
if page:
form = PageForm(initial=page.__dict__)
else:
form = PageForm(initial={'name': name})
return render_to_response('wiki/edit.html', {
'form': form,
'admin': is_admin(request),
'user': get_user(request),
'navbar':Page.objects.get(name='NavBar'),
})
def test_merge_conflict(self):
p = Page()
p.content = '<p>old content</p>'
p.name = 'Front Page'
p.save()
a = PageForm(instance=p)
b = PageForm(instance=p)
b_post = b.initial
b_post['content'] = '<p>b content</p>'
b = PageForm(b_post, instance=p)
self.failUnless(b.is_valid())
b.save()
p = Page.objects.get(pk=p.pk)
a_post = a.initial
a_post['content'] = '<p>a content</p>'
a = PageForm(a_post, instance=p)
self.failIf(a.is_valid())
self.failUnless(PageForm.conflict_error in str(a.errors))
a_post = a.data
a = PageForm(a_post, instance=p)
self.failUnless(a.is_valid())
a.save()
p = Page.objects.get(pk=p.pk)
self.failUnless('Edit conflict!' in p.content)
def add_page(request, category_name_url):
context = RequestContext(request)
context_dict = {}
category_name = decode_url(category_name_url)
if request.method == 'POST':
form = PageForm(data=request.POST)
if form.is_valid():
page = form.save(commit=False)
try:
cat = Category.objects.get(name=category_name)
page.category = cat
except Category.DoesNotExist:
return render_to_response('rango/add_page.html', context_dict,
context)
page.views = 0
page.save()
return category(request, category_name_url)
else:
print form.errors
else:
form = PageForm()
context_dict['category_name_url'] = category_name_url
context_dict['category_name'] = category_name
context_dict['form'] = form
return render_to_response('rango/add_page.html', context_dict, context)
def add_page(request, category_name_slug):
"""
view for adding news pages
-it displays the form
- validates the form
- updates the database
-return to success or failure page
"""
try:
category = Category.objects.get(slug= category_name_slug)
except Category.DoesNotExist:
category = None
form = PageForm()
if request.method=="POST":
form = PageForm(request.POST)
#check if form is valid
if form.is_valid():
if category:
#create a page object by saving the form
page = form.save(commit=False) #don't save the page object yet into the database
page.category = category
page.views = 0
#no save the page object into the database
page.save()
#return to the succes page, in this case the index page which also shows the top 5 pages
return show_category(request, category_name_slug)
else:
#form contain invalid date, so print errors
print form.errors
context_dict = {'category':category, 'form':form}
#render the form with error messages if any
return render(request, 'news/add_page.html', context_dict)
def edit(request, name):
"""Allows users to edit wiki pages."""
try:
page = Page.objects.get(name=name)
except Page.DoesNotExist:
try:
page = Page.objects.get(name=name.title())
except Page.DoesNotExist:
page = Page(name=name)
if request.method == 'POST':
form = PageForm(request.POST)
if form.is_valid():
page.name = form.cleaned_data['name']
page.content = form.cleaned_data['content']
if not page.order:
page.order = Page.objects.latest('order').order + 1
page.save()
return redirect(view, name=page.name)
else:
if page:
form = PageForm(initial=page.__dict__)
else:
form = PageForm(initial={'name': name})
context = {'form': form, 'page': page, 'pages': Page.objects.all()}
return render_to_response('wiki/edit.html',
RequestContext(request, context))
def add_page(request):
context = RequestContext(request)
if request.method == 'POST':
form = PageForm(request.POST)
if form.is_valid():
form.save(commit=True)
return index(request)
else:
print form.errors
else:
form = PageForm()
return render_to_response('rango/add_page.html', {'form': form}, context)
def new_site():
user = users.get_current_user()
form = PageForm(request.form)
if request.method == 'POST':
if form.validate():
site = Site(
name=form.name.data,
owner=user,
users=[user],
admins=[user],
)
site.put()
page = Page.new_page(site, form.name.data, form.url.data)
new_url = url_for('editor', page_id=page.key().id())
if request.is_xhr:
return jsonify(dict(type='success', redirect=new_url))
else:
return redirect(new_url)
elif request.is_xhr:
return jsonify(
dict(type='error',
errors=render_template('form_errors.html', form=form)))
if request.is_xhr:
return render_template('site_creator.html', form=form)
return render_template('new_site.html', form=form)
def page_edit_static(request, id):
shop = request.shop
page = get_object_or_404(Page, pk=id)
page_name = page.name
page_name_link = page.name_link
page_title = page.title
page_body = page.body
page_meta_content = page.meta_content
static_pages = Page.objects.filter(shop=shop)
dynamic_pages = DynamicPageContent.objects.filter(shop=shop)
form = PageForm(shop, request.POST or None, instance=page)
if request.method == "POST":
if form.is_valid():
new_page = form.save(commit=False)
new_page.save()
version = PageVersion(page=page)
version.name = page_name
version.name_link = page_name_link
version.title = page_title
version.body = page_body
version.meta_content = page_meta_content
version.save()
request.flash['message'] = unicode(_("Page successfully edited."))
request.flash['severity'] = "success"
return HttpResponseRedirect(reverse('page_edit_static', args=[id]))
return render_to_response(
'store_admin/web_store/pages_edit_static_page.html', {
'form': form,
'page': page,
'static_pages': static_pages,
'dynamic_pages': dynamic_pages
}, RequestContext(request))
def submitnewpage(request, parentid, book):
if request.user.is_authenticated() and request.method == "POST":
if (not parentid and user.is_staff()) or parentid:
form = PageForm(request.POST, request.FILES)
if form.is_valid():
page = Page()
if int(parentid):
page.parent = Page.objects.all().get(id=parentid)
else:
page.parent = None
page.author = request.user
page.short_desc = form.cleaned_data['short_desc']
if request.FILES.get('video'):
page.video = 'https://player.vimeo.com' + (Vimeo_Upload(
request.FILES.get('video')))
if request.FILES.get('illustration'):
page.illustration = request.FILES.get('illustration')
page.video = None
page.long_desc = form.cleaned_data['long_desc']
page.book = get_object_or_404(Book, pk=int(book))
page.save()
return HttpResponseRedirect("/page:" + str(page.id) + "/")
else:
return render_to_response(
"writinganewpage.html", {
'form': form,
'parentid': parentid,
"book": book
},
context_instance=RequestContext(request))
return goHome()
def submiteditedpage(request, pageid):
if request.user.is_authenticated() and request.method == "POST":
page = findPage(pageid)
if not page:
return go404()
if request.user.is_staff or page.author == findUser(request.user):
if request.FILES:
files = request.FILES
elif page.illustration:
files = {'illustration': page.illustration}
else:
files = {}
form = PageForm(request.POST, files)
if form.is_valid():
page.short_desc = form.cleaned_data['short_desc']
page.illustration = files.get('illustration')
page.long_desc = form.cleaned_data['long_desc']
if request.FILES.get('video'):
page.video = 'https://player.vimeo.com' + (Vimeo_Upload(
request.FILES.get('video')))
page.save()
return HttpResponseRedirect("/page:" + str(page.id) + "/")
else:
return render_to_response(
"editingapage.html", {
'form': form,
'page': page
},
context_instance=RequestContext(request))
return goHome()
def edit_page():
form = PageForm(request.form)
name = request.args['page']
doc = db.static.find_one({'name': name})
menu = Markup(db.static.find_one({'name': 'menu'})['content'])
if request.method == 'POST':
new_title = form.page_title.data
new_content = form.page_content.data
new_name = form.page_name.data
db.static.update({'name': name}, {
"$set": {
'content': new_content,
'title': new_title,
'name': new_name
}
})
return redirect(url_for('edit_pages'))
file_title = Markup(doc['title'])
file_markup = Markup(doc['content'])
form.page_title.data = file_title
form.page_name.data = name
form.page_content.data = file_markup
return render_template('edit.html', form=form, menu=menu, rss=False)
def index():
user = users.get_current_user()
if user:
if not UserSettings.has_seen_example() and GqlQuery(
'SELECT __key__ FROM Site WHERE owner=:1 AND example=true',
user).count(1) == 0:
_create_example_site(user)
UserSettings.mark_example_as_seen()
sites = Site.gql('WHERE users=:1 ORDER BY name', user)
site_form = PageForm()
page_form = PageForm()
return render_template('index.html',
sites=sites,
new_site_form=site_form,
page_form=page_form)
else:
return home()
def add_page(request, category_name_url):
"""
Add page to category if it doesn't exist,
:param request
:param category_name_url
"""
category_name = Category._encode_url_name(category_name_url,
Category._url_decode_rules_dict)
# category_name = "ooops"
cat = None
if request.method == "POST":
form = PageForm(request.POST)
if form.is_valid():
# Cannot commit straight away, not all fields automatically populated
page = form.save(commit=False)
# Retrieve the associated Category object so we can add it
# Handle exception for Model.DoesNotExist, Go back and render the add category form
try:
cat = Category.objects.get(url=category_name_url)
page.category = cat
except Category.DoesNotExist:
# Category does not exist, Go back and the render the add_category form
return _process_request(request, {}, "rango/add_category.html")
# set default value for number of views, and save new model instance
page.views = 0
page.save()
# Now that the page is saved, display the category instead.
return category(request, category_name_url)
else:
print form.errors
else:
form = PageForm()
context_dict = {
"category_name_url": category_name_url,
"category_name": category_name,
"form": form,
}
return _process_request(request, context_dict, "rango/add_page.html")
def edit(page_id):
page = Page.objects.with_id(page_id)
form = PageForm(request.form, page)
if form.validate_on_submit():
form.populate_obj(page)
page.save()
return redirect('/wiki/')
return render_template('wiki_edit.html',
title="Wiki - edit page " + page.title,
page=page,
form=form)
def create():
page = Page()
form = PageForm(request.form, page)
if form.validate_on_submit():
form.populate_obj(page)
page.save()
return redirect('/wiki/')
return render_template('wiki_create.html',
title="Wiki - create new page",
page=page,
form=form)
def add_page(request, category_slug):
context_dict = {}
cat = Category.objects.get(slug=category_slug)
context_dict['category'] = cat
if request.method == 'POST':
form = PageForm(request.POST)
if form.is_valid():
if cat:
page = form.save(commit=False)
page.category = cat
page.views = 0
page.save()
return category(request, category_slug)
else:
print form.errors
else:
form = PageForm()
context_dict['form'] = form
return render(request, 'rango/add_page.html', context_dict)
def add_page(request, category_name_url):
context = RequestContext(request)
cat_list = get_category_list()
context_dict = {}
context_dict['cat_list'] = cat_list
category_name = decode_url(category_name_url)
if request.method == 'POST':
form = PageForm(request.POST)
if form.is_valid():
# This time we cannot commit straight away.
# Not all fields are automatically populated!
page = form.save(commit=False)
# Retrieve the associated Category object so we can add it.
try:
cat = Category.objects.get(name=category_name)
page.category = cat
except Category.DoesNotExist:
return render_to_response('rango/add_page.html', context_dict,
context)
# Also, create a default value for the number of views.
page.views = 0
# With this, we can then save our new model instance.
page.save()
# Now that the page is saved, display the category instead.
return category(request, category_name_url)
else:
print form.errors
else:
form = PageForm()
context_dict['category_name_url'] = category_name_url
context_dict['category_name'] = category_name
context_dict['form'] = form
return render_to_response('rango/add_page.html', context_dict, context)
def add_page(request, category_name_slug):
try:
category = Category.objects.get(slug=category_name_slug)
except Category.DoesNotExist:
category = None
form = PageForm()
if request.method == 'POST':
form = PageForm(request.POST)
if form.is_valid():
if category:
page = form.save(commit=False)
page.category = category
page.views = 0
page.save()
# probably better to use a redirect here.
return show_category(request, category_name_slug)
else:
print(form.errors)
context_dict = {'form':form, 'category': category}
return render(request, 'rango/add_page.html',context=context_dict)
def editpage(request, pageid):
page = findPage(pageid)
if not page:
return go404()
if request.user.is_staff or page.author == findUser(request.user):
already_written = {
'short_desc': page.short_desc,
'long_desc': page.long_desc
}
form = PageForm(already_written)
return render_to_response("editingapage.html", {
'form': form,
'page': page
},
context_instance=RequestContext(request))
return goHome()
def create_page():
form = PageForm(request.form)
menu = Markup(db.static.find_one({'name': 'menu'})['content'])
if request.method == 'POST' and form.validate():
title = form.page_title.data
content = form.page_content.data
name = form.page_name.data
db.static.insert({
'name': name,
'content': content,
'title': title,
'type': 'page'
})
return redirect(url_for('edit_pages'))
return render_template('edit.html', form=form, menu=menu)
def get(self, page_id=None, **kwargs):
"""Return a page to edit or an empty form to create"""
template = 'admin/page/new.html'
context = {
'form': self.form,
}
# render edit
if page_id is not None:
page = Page.get_by_id(page_id)
if page:
self.form = PageForm(obj=page)
context.update({'form': self.form})
template = 'admin/page/edit.html'
else:
return redirect('admin/page/')
# render new
return self.render_response(template, **context)
def new_page(site_id):
site = Site.get_admin_or_404(site_id)
form = PageForm(request.form, site=site)
if request.method == 'POST':
if form.validate():
page = Page.new_page(site, form.name.data, form.url.data)
new_url = url_for('editor', page_id=page.key().id())
if request.is_xhr:
return jsonify(dict(type='success', redirect=new_url))
return redirect(new_url)
elif request.is_xhr:
return jsonify(
dict(type='error',
errors=render_template('form_errors.html', form=form)))
if request.is_xhr:
return render_template('page_creator.html', form=form, site=site)
return render_template('new_page.html', form=form, site=site)
def page_create(request):
shop = request.shop
static_pages = Page.objects.filter(shop=shop)
dynamic_pages = DynamicPageContent.objects.filter(shop=shop)
form = PageForm(shop, request.POST or None)
if form.is_valid():
page = form.save(commit=False)
page.shop = shop
page.save()
request.flash['message'] = unicode(_("Page successfully saved."))
request.flash['severity'] = "success"
return HttpResponseRedirect(reverse('web_store_pages'))
return render_to_response(
'store_admin/web_store/pages_page_create.html', {
'form': form,
'static_pages': static_pages,
'dynamic_pages': dynamic_pages,
}, RequestContext(request))
def submiteditedpage(request, pageid):
if request.user.is_authenticated() and request.method == "POST":
page = findPage(pageid)
if not page:
return go404()
if request.user.is_staff or page.author == findUser(request.user):
form = PageForm(request.POST, request.FILES)
if form.is_valid():
page.short_desc = form.cleaned_data['short_desc']
page.illustration = request.FILES['illustration']
page.long_desc = form.cleaned_data['long_desc']
page.save()
return HttpResponseRedirect("/page:" + str(page.id) + "/")
else:
return render_to_response(
"editingapage.html", {
'form': form,
'page': page
},
context_instance=RequestContext(request))
return goHome()
def edit_page(page_id):
page = Page.get_admin_or_404(page_id)
form = PageForm(request.form, page)
if request.method == 'POST':
if form.validate():
if form.data['url'] != page.url:
page.queue_preview()
page.name = form.name.data
page.url = form.url.data
page.preview_urls = [Link(url.data) for url in form.preview_urls]
page.put()
if request.is_xhr:
return 'OK'
elif request.is_xhr:
return render_template('form_errors.html', form=form)
if request.is_xhr:
return render_template('page_editor.html', form=form, page=page)
return render_template('edit_page.html',
form=form,
site=page.site,
page=page)
def page_edit(id=None):
"""edit or create a page"""
page = g.db.pages.find_one({'_id': id})
if id:
if page is None:
abort(404)
else:
# create a NEW page here
page = {'owner': g.username}
if page.get('owner') != g.username and not (g.is_admin):
flash("You are not the page owner", category="danger")
return redirect(url_for('site', path=page['slug']))
if page.get('is_markup'):
page_template = 'generic_form.html'
form = PageForm()
else:
page_template = 'generic_form_ckedit.html'
form = HTMLPageForm()
if form.validate_on_submit():
page = form2object(form, page)
if form.slug.data == '':
page['slug'] = slugify(page['title'])
if id:
g.db.pages.update_one({'_id': id}, page)
else:
g.db.pages.insert_one(page)
flash('Page saved.', category="info")
return redirect(url_for('site', path=page.get('slug')))
if request.method == 'GET':
# get the data from the page-object into the form
form = object2form(page, form)
return render_template(page_template, form=form, id=id, title="Edit page")
def setUp(self):
self.client = Client()
try:
populate()
except ImportError:
print('The module populate_rango does not exist')
except NameError:
print('The function populate() does not exist or is not correct')
except:
print('Something went wrong in the populate() function :-(')
# Check forms are defined
try:
from forms import PageForm
from forms import CategoryForm
PageForm()
CategoryForm()
except ImportError:
print('The module forms does not exist')
except NameError:
print('The class PageForm does not exist or is not correct')
except Exception:
print('Something else went wrong :-(')
