def main():
import connection
labels = Label.objects(name='_testing')
if labels.count():
label = labels.first()
else:
label = labels.upsert_one(name='_testing')
post1 = Page(title="Foo",
content="<div>Foo bar</div>",
url='https://foo.bar.com',
label=label)
print(repr(post1))
post1.save()
print()
post2 = Page(title="Bar",
content="<div>Fizz</div>",
url='https://fub.buzz.com',
label=label)
print(repr(post2))
post2.save()
print()
posts = Page.objects(label=label)
print(posts.count())
print(posts)
print()
print("Deleting")
post1.delete()
post2.delete()
def post(self, slug=None):
f = page_form()
data = self.get_arguments()
is_edit = data.has_key('ori_slug')
_ = self._
try:
attachments = self.get_argument('attachments', None)
if attachments:
data['attachments'] = parse_attachments(
data['attachments'], is_edit)
if f.validates(tornado.web._O(data)):
page = Page.one({'type': 'Page', 'slug': data['ori_slug']}) \
if is_edit else Page()
page.save(data, user=self.current_user)
if attachments:
page['attachments'] = move_attachments(
self.settings.upload_path, data['attachments'])
page.update_html()
page.save()
self.set_flash(_("Page has been saved."))
self.redirect(page.get_url())
return
page = Page()
raise Exception(_("Invalid form data."))
except Exception, e:
if attachments:
page['attachments'] = data['attachments']
f.note = f.note if f.note else e
self.render("page-edit", f=f, page=page, user=self.current_user)
def setup_database(app):
with app.app_context():
db.create_all()
home = Page()
home.name = "Home"
contact = Page()
contact.name = Page()
db.session.add(home)
db.session.add(contact)
db.session.commit()
def get_queryset(self):
all_page_versions = Page(slug=self.kwargs['slug']).versions.all()
# We set self.page to the most recent historical instance of the
# page.
if all_page_versions:
self.page = all_page_versions[0]
else:
self.page = Page(slug=self.kwargs['slug'],
name=self.kwargs['original_slug'])
return all_page_versions
def test_edit_page(self):
page = Page(title='test title',
address='test_page',
content='test content')
db.session.add(page)
assert self.is_only_for_admins('/edit/test_page/')
self.login_as_admin()
response = self.client.get('/edit/test_page/')
assert response.status_code == 200
# title and content edit
new_data = {
'address': 'changed_address',
'title': 'changed title',
'content': 'changed content'
}
self.client.post('/edit/test_page/',
data=new_data,
follow_redirects=True)
assert page.address == new_data['address']
assert page.title == new_data['title']
assert page.content == new_data['content']
with self.assert_flashes('Address cannot be empty'):
response = self.client.post(
'/edit/changed_address/',
data={
'address':
'',
'content':
'I accidentally removed address but want the content preserved!'
},
follow_redirects=True)
# user should get their edited text back (no one likes to loose his work)
assert b'I accidentally removed address but want the content preserved!' in response.data
# but the actual text should not be changed
assert page.content == 'changed content'
assert page.address == 'changed_address'
# weird addresses
for weird_address in self.weird_addresses:
page = Page(address=weird_address)
db.session.add(page)
response = self.client.post('/edit/' + weird_address + '/',
data={'title': 'new title'})
assert response.status_code == 200
assert page.title == 'new title'
self.logout()
def doc_root():
pickups = Page().query(Page.page_type == 'article')
pickups = pickups.filter(Page.is_pickup == True)
pickups = pickups.filter(Page.published_at != None)
pickups = pickups.filter(Page.published_at < datetime.now())
pickups = pickups.order(-Page.published_at)
pages = Page().query(Page.page_type == 'article')
pages = pages.filter(Page.is_pickup == False)
pages = pages.filter(Page.published_at != None)
pages = pages.filter(Page.published_at < datetime.now())
pages = pages.order(-Page.published_at)
T = {'pages': pages, 'pickups': pickups}
return render_template('pages_top.html', T=T)
def create_step(course_id, theme_id):
step = Step(content_type=request.form.get('content_type'),
theme_id=theme_id)
db.session.add(step)
db.session.commit()
if step.content_type == 'text':
text = bleach.clean(request.form.get('text'))
page = Page(step_id=step.id, text=text)
db.session.add(page)
db.session.commit()
image_ids = request.form.getlist('image_id')
images = Image.query.filter(Image.id.in_(image_ids))
for img in images:
img.object_type = page.__tablename__
img.object_id = page.id
img.active = True
db.session.add(img)
db.session.commit()
return redirect(
url_for(
'courses.show_content',
course_id=course_id,
theme_id=theme_id,
step_id=step.id,
))
def get(self, book_id):
book = Book(book_id)
pages = [
PageSerializer(Page(pageId, book)).data for pageId in book.pagesId
]
# return PageSerializer(pages).data
return jsonify(data=pages)
def main():
"""
Main command-line function.
"""
name = 'Testing'
label = Label.objects(name=name).upsert_one(name=name)
lines = lib.read('var/chrome_onetab.txt')
pages = [
dict(zip(('url', 'title'), line.split(' | ', 1))) for line in lines
]
for page in pages[:10]:
url = page['url']
print(url)
resp = requests.get(url)
print(resp.status_code, resp.reason)
body = resp.text
print(len(body))
page_rec = Page(
title=page['title'],
url=url,
content=body,
status_code=resp.status_code,
label=label,
)
page_rec.save()
print()
def view_diff(request, name, rev=None):
"""Shows the diffs for a wiki revision"""
try:
page = Page.objects.get(name=name)
if rev is not None:
rev = int(rev)
revision = get_object_or_404(Revision, page=page, counter=rev)
else:
revision = page.get_latest_revision()
except Page.DoesNotExist:
page = Page(name=name)
revision = None
# compute diff
import difflib
prev_content = ""
if revision and revision.get_prev():
prev_content = revision.get_prev().content
#diff = difflib.HtmlDiff().make_table(revision.content.splitlines(), prev_content.splitlines())
d = difflib.Differ()
diff = d.compare(prev_content.splitlines(), revision.content.splitlines())
diff = '\n'.join(list(diff))
ctx = { 'page': page, 'revision': revision, 'diff': diff }
return render_to_response('wiki/diff.html', ctx, context_instance=RequestContext(request))
def _create_example_site(user):
site = Site(
name='Example Site',
owner=user,
users=[user],
admins=[user],
example=True,
)
site.put()
for v in [4, 5]:
name = 'Html%d Example' % v
style = Style(site=site, name=name)
style.put()
rev = StyleRevision(parent=style, rev=0)
rev.put()
rev.update(render_template('examples/blog-html%d.css' % v))
style.published_rev = rev
rev = StyleRevision(parent=style, rev=1)
rev.put()
rev.update(render_template('examples/blog-html%d-preview.css' % v))
style.preview_rev = rev
style.put()
page = Page(site=site,
name=name,
url=url_for('example%d' % v, page_key=0, _external=True),
_styles=[style.key()])
page.put()
page.url = url_for('example%d' % v,
page_key=page.key(),
_external=True)
page.put()
page.queue_refresh()
def get_object(self, request, region='', slug=''):
self.setup_region(region)
obj = Page(slug=slugify(slug), region=self.region)
obj.title = obj.versions.most_recent().name
obj.page = obj
return obj
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 page(issue_no):
context = Page(issue_no).getContext()
print(issue_no)
print('[DEBUG] page ', context)
context['title'] = 'FiftyPercent - No.' + issue_no
# toggler icon
return render_template('page.html', context=context)
def main(request, resource):
if request.user.is_authenticated():
logged = ("Logged in as " + request.user.username
+ " <a href='/admin/logout/'>Log out</a>")
else:
logged = ("Not logged in. "
+ "<a href='/admin/login/?next=/admin/'>Log in</a>")
if request.method == "GET":
try:
page_entry = Page.objects.get(name=resource)
return HttpResponse(logged + "<br/>" + page_entry.page)
except Page.DoesNotExist:
if resource == "":
resource = "Main Page"
return HttpResponseNotFound(logged + "<br/>"
+ "Page not found: %s." % resource)
elif request.method == "PUT":
new_entry = Page(name=resource, page=request.body)
new_entry.save()
return HttpResponse(logged + "<br/>"
+ "Succesful PUT operation: " + request.body)
else:
return HttpResponseForbidden(logged + "<br/>"
+ "Operation not available")
def test_step4_switch_project(self, browser, baseurl, private_project):
project = private_project
page_object = Page(browser, baseurl)
page_object.switch_project(project)
assert project == page_object.get_project_name()
def page_edit_about(request):
shop = request.shop
static_pages = Page.objects.filter(shop=shop)
dynamic_pages = DynamicPageContent.objects.filter(shop=shop)
try:
about = About.objects.filter(shop=shop).get()
except About.DoesNotExist:
about = Page(shop=shop)
about.save()
if request.method == "POST":
form = AboutForm(request.POST)
if form.is_valid():
about.title = form.cleaned_data['title']
about.body = form.cleaned_data['body']
about.meta_content = form.cleaned_data['meta_content']
about.save()
request.flash['message'] = unicode(_("Page successfully saved."))
request.flash['severity'] = "success"
return HttpResponseRedirect(reverse('page_edit_about'))
else:
form = AboutForm(instance=about)
return render_to_response('store_admin/web_store/pages_edit_about.html', {
'form': form,
'static_pages': static_pages,
'dynamic_pages': dynamic_pages
}, RequestContext(request))
def mostrar(request, resource):
salida = ""
if request.user.is_authenticated():
salida += "<p>Hi " + request.user.username + ". "
salida += "<a href='/logout/'>Logout</a></p>"
else:
salida += "<p>You aren't logged in. "
salida += "<a href='/admin/login/'>Login!</a></p>"
if request.method == "GET":
try:
fila = Page.objects.get(name=resource)
return HttpResponse(salida + fila.page)
except Page.DoesNotExist:
return HttpResponseNotFound(salida + 'Page not found: ' + resource)
except Page.MultipleObjectsReturned:
return HttpResponseNotFound(salida + 'Server allocated more than \
one page for that resource')
elif request.method == "PUT":
if request.user.is_authenticated():
newpage = Page(name=resource, page=request.body)
newpage.save()
return HttpResponse(salida + "New page added:\n" + request.body)
else:
salida += "YOU MUST <a href='/admin/login/'>LOG IN</a>"
return HttpResponse(salida)
else:
return HttpResponseForbidden(salida + "Method not allowed")
def add_page(self):
if request.method == 'GET':
return self._template('admin/add_page', )
page_data = dict_subset(request.form, Page.columns)
try:
address = request.form['address']
if not address:
raise ValidationError('Address cannot be empty')
page = Page(**page_data)
db.session.add(page)
db.session.commit()
flash('Added new page: ' + link_to_page(page), 'success')
return redirect(
url_for('ContentManagementSystem:edit_page', address=address))
except ValidationError as error:
flash(error.message, 'warning')
except IntegrityError:
db.session.rollback()
flash('Something went wrong.', 'danger')
return self._template('admin/add_page', page=page_data)
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 insert_site(self, domain, robots, url, session):
sitemaps = list(robots.sitemaps) # get sitemaps
if domain not in self.scraped_sites:
site = Site(domain=domain,
robots_content=str(robots),
sitemap_content=sitemaps)
session.add(site)
session.commit()
site_id = site.id
self.scraped_sites.add(domain)
page = Page(site_id=site_id, page_type_code='FRONTIER', url=url)
session.add(page)
session.commit()
page_id = page.id
self.scraped_pages.add(url)
if len(sitemaps) > 0:
r = requests.get(sitemaps[0])
root = etree.fromstring(r.content)
for sitemap in root:
children = sitemap.getchildren()
candidate = children[
0].text # if sitemap link is not in frontier, add to it
if candidate not in self.scraped_pages:
self.frontier.put(candidate)
self.insert_page(site_id, candidate, page_id, session)
else:
site = session.query(Site).filter(Site.domain == domain).first()
site_id = site.id
return site_id
def error404(request):
return {
'p':
Page(title=u'Такой страницы не найдено',
content=
u'Такой страницы не существует. Воспользуйтесь поиском по сайту')
}
def uniqueness(s):
stmt = s.query(Site).filter(Site.domain == 'evem.gov.si')
site = stmt.first()
if site is not None:
site_id = site.id
print(site_id)
now = datetime.datetime.now().date()
b = bytes("<div></div>", 'utf-8')
m = hashlib.md5()
m.update(b)
hashed = m.digest()
page = Page(
site_id=site_id,
page_type_code='HTML',
url='https://www.najdi.si', # UNIQUE
html_content='<div>Goodbye</div>',
http_status_code=200,
accessed_time=now,
hash=hashed)
try:
s.add(page)
s.commit()
except Exception as e:
print(e)
def show_pages_tag(tag):
pages = Page().query(Page.page_type == 'article')
pages = pages.filter(Page.published_at != None)
pages = pages.filter(Page.published_at < datetime.now())
pages = pages.filter(Page.tags == tag)
pages = pages.order(-Page.published_at)
return show_pages(pages)
def add_chapter(manga, chapter_name, chapter_num, pages):
# Ensure that chapter_num is a float
chapter_num = float(chapter_num)
# Ensure that the manga does not have a chapter with the same number
if manga.chapters.filter_by(num=chapter_num).first():
return
new_chapter = Chapter(chapter_name, chapter_num, manga)
# Representation is different if its an integer
num_string = chapter_to_string(chapter_num)
# Make a new folder for the chapter
url = new_chapter.manga.url + "/Chapter_" + num_string
# Rename and add all the chapter pages
curr_page = 1
for page in pages:
# Skip resource forks
if "__MACOSX" in page.filename:
continue
filename = rename(page, "%03d" % curr_page)
# Make sure nothing that isn't an image file doesn't get through.
if not allowed_file(page.filename):
continue
new_page = Page(curr_page, save_file(page, url, filename), new_chapter)
db.session.add(new_page)
# Remember to increment curr_page
curr_page += 1
zip_directory(manga, num_string, url)
# Manga has been updated, so update the last updated date
manga.last_updated = datetime.utcnow()
# Add and commit to the database
db.session.add(new_chapter)
db.session.commit()
def test_page_parents(self):
book = self.create_book("jump to python")
p1 = Page(subject="p1", content="..", book=book)
p1.save()
p2 = Page(subject="p2", content="..", book=book, parent=p1)
p2.save()
p3 = Page(subject="p3", content="..", book=book, parent=p2)
p3.save()
p4 = Page(subject="p4", content="..", book=book, parent=p2)
p4.save()
self.assertFalse(p1.get_parents())
self.assertTrue(p1 in p2.get_parents())
self.assertTrue(p1 in p3.get_parents())
self.assertTrue(p2 in p3.get_parents())
self.assertTrue(p1 in p4.get_parents())
async def parse(article, session, recursion_depth, from_page_id, limit_rd=1):
async with SEMA:
global URL
task = [asyncio.ensure_future(fetch(URL.format(article), session))]
response = await asyncio.gather(*task)
data = html.fromstring(response[0])
anchors = data.xpath('//a[@title]')
entities = []
for anchor in anchors:
href = unquote(anchor.attrib['href'])
# проверить, что урл начинается с /wiki, а также этот урл не повторяется в БД
if not is_valid_ref(
href, db_session
) or 'страница отсутствует' in anchor.attrib['title']:
continue
page = Page(url=URL.format(href), from_page_id=from_page_id)
db_session.add(page)
db_session.commit()
db_session.refresh(page)
entities.append((page.id, href))
# Если дошли до конца рекурсии, останавливаемся
if recursion_depth > limit_rd:
return
# Создаем новый ивент-луп под полученные ссылки, и также рекурсивно запускаем эту функцию под них
subtasks = []
for page_id, page_url in entities:
subtasks.append(
asyncio.ensure_future(
parse(page_url, session, recursion_depth + 1, page_id)))
await asyncio.gather(*subtasks)
def inicio(request):
if request.method == "POST":
url = request.POST.get('url')
url = procUrl(url)
try:
encontrada = Page.objects.get(url_original=url)
except Page.DoesNotExist:
pag = Page(url_original=url)
pag.save()
encontrada = Page.objects.get(url_original=url)
respuesta = '<a href ="' + str(encontrada.id) + '">'
respuesta += "http://localhost:1234/" + str(encontrada.id) + '</a>'
return HttpResponse(respuesta)
listado = Page.objects.all()
respuesta = "<ol>"
for elemento in listado:
respuesta += '<li><a href ="' + str(elemento.url_original) + '">'
respuesta += str(elemento.url_original) + '</a>' + " = "
respuesta += '<a href="' + str(elemento.id) + '">'
respuesta += "http://localhost:1234/" + str(elemento.id) + '</a>'
respuesta += "</ol>"
template = get_template("pag.html")
argumentos = {
'contenido': respuesta,
}
return HttpResponse(template.render(Context(argumentos)))
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 processCmsRequest(request, resource):
if request.user.is_authenticated():
loged = "<br><br>Logged in as " + request.user.username +\
". <a href='/admin/logout/'>Logout</a><br>"
else:
loged = "<br><br>Not logged. <a href='/admin/login/'>Login</a><br>"
if request.method == 'GET':
try:
page = Page.objects.get(name=resource)
return HttpResponse(page.page + loged)
except Page.DoesNotExist:
return HttpResponseNotFound("Page not found" + loged)
elif request.method == 'PUT':
if request.user.is_authenticated():
try:
newPage = Page.objects.get(name=resource)
newPage.page = request.body
except Page.DoesNotExist:
newPage = Page(name = resource, page = request.body)
newPage.save()
return HttpResponse("Added to the list")
else:
return HttpResponse("Couldn't add to the list" + loged)
else:
return HttpResponse(status=403)
