def edit_book(request, bookid, version=None):
"""
Django View. Default page for Booki editor.
@param request: Django Request
@param bookid: Book ID
@param version: Book Version or None
"""
from booki.utils import security
try:
book = models.Book.objects.get(url_title__iexact=bookid)
except models.Book.DoesNotExist:
return pages.ErrorPage(request, "errors/book_does_not_exist.html", {"book_name": bookid})
book_version = getVersion(book, version)
bookSecurity = security.getUserSecurityForBook(request.user, book)
hasPermission = security.canEditBook(book, bookSecurity)
if not hasPermission:
return pages.ErrorPage(request, "errors/editing_forbidden.html", {"book": book})
chapters = models.Chapter.objects.filter(version=book_version)
tabs = ["chapters"]
if True: # bookSecurity.isAdmin():
tabs += ["attachments"]
tabs += ["history", "versions", "notes"]
if bookSecurity.isAdmin():
tabs += ["settings"]
tabs += ["export"]
isBrowserSupported = True
browserMeta = request.META.get('HTTP_USER_AGENT', '')
if browserMeta.find('MSIE') != -1:
isBrowserSupported = False
return render_to_response('editor/edit_book.html', {"book": book,
"book_version": book_version.getVersion(),
"version": book_version,
## this change will break older versions of template
"statuses": [(s.name.replace(' ', '_'), s.name) for s in models.BookStatus.objects.filter(book = book)],
"chapters": chapters,
"security": bookSecurity,
"is_admin": bookSecurity.isGroupAdmin() or bookSecurity.isBookAdmin() or bookSecurity.isSuperuser(),
"is_owner": book.owner == request.user,
"tabs": tabs,
"is_browser_supported": isBrowserSupported,
"request": request})
def view_full(request, bookid, version=None):
"""
Django View. Shows full content of book on one page. This is published version of a book.
@type request: C{django.http.HttpRequest}
@param request: Django Request
@type bookid: C{string}
@param bookid: Unique Book ID
@type version: C{string}
@param version: Version of the book
"""
chapters = []
try:
book = models.Book.objects.get(url_title__iexact=bookid)
except models.Book.DoesNotExist:
return pages.ErrorPage(request, "errors/book_does_not_exist.html",
{"book_name": bookid})
book_version = book.getVersion(version)
from booki.utils import security
bookSecurity = security.getUserSecurityForBook(request.user, book)
hasPermission = security.canEditBook(book, bookSecurity)
if book.hidden and not hasPermission:
return pages.ErrorPage(request, "errors/no_permissions.html")
for chapter in models.BookToc.objects.filter(
version=book_version).order_by("-weight"):
if chapter.isChapter():
chapters.append({
"type": "chapter",
"title": chapter.chapter.title,
"content": chapter.chapter.content,
"chapter": chapter.chapter
})
else:
chapters.append({"type": "section", "title": chapter.name})
return render_to_response(
'reader/full.html', {
"book": book,
"book_version": book_version.getVersion(),
"chapters": chapters,
"has_css": _customCSSExists(book.url_title),
"request": request
})
def draft_book(request, bookid, version=None):
"""
Django View. Shows main page for the draft version of a book.
@type request: C{django.http.HttpRequest}
@param request: Client Request object
@type bookid: C{string}
@param bookid: Unique Book ID
@type version: C{string}
@param verson: Book version
"""
try:
book = models.Book.objects.get(url_title__iexact=bookid)
except models.Book.DoesNotExist:
return pages.ErrorPage(request, "errors/book_does_not_exist.html",
{"book_name": bookid})
book_version = book.getVersion(version)
from booki.utils import security
bookSecurity = security.getUserSecurityForBook(request.user, book)
hasPermission = security.canEditBook(book, bookSecurity)
if book.hidden and not hasPermission:
return pages.ErrorPage(request, "errors/no_permissions.html")
chapters = []
for chapter in models.BookToc.objects.filter(
version=book_version).order_by("-weight"):
if chapter.isChapter():
chapters.append({
"url_title": chapter.chapter.url_title,
"name": chapter.chapter.title
})
else:
chapters.append({"url_title": None, "name": chapter.name})
return render_to_response(
'reader/draft_book.html', {
"book": book,
"book_version": book_version.getVersion(),
"chapters": chapters,
"has_css": _customCSSExists(book.url_title),
"request": request
})
def view_group(request, groupid):
"""
Django View. This is main Booki Groups page.
@type request: C{django.http.HttpRequest}
@param request: Client Request object
@type groupid: C{string}
@param groupid: Unique group name
"""
try:
group = models.BookiGroup.objects.get(url_name=groupid)
except models.BookiGroup.DoesNotExist:
return pages.ErrorPage(request, "errors/group_does_not_exist.html",
{"group_name": groupid})
except models.BookiGroup.MultipleObjectsReturned:
return pages.ErrorPage(request, "errors/group_does_not_exist.html",
{"group_name": groupid})
books = models.Book.objects.filter(group=group, hidden=False)
members = group.members.all()
isMember = request.user in members
if request.user.is_authenticated():
yourBooks = models.Book.objects.filter(owner=request.user)
else:
yourBooks = []
bs = security.getUserSecurityForGroup(request.user, group)
history = models.BookHistory.objects.filter(book__group=group)[:20]
n_members = len(members)
n_books = len(books)
return render_to_response(
'portal/group.html', {
"request": request,
"title": "Ovo je neki naslov",
"group": group,
"books": books,
"n_books": n_books,
"your_books": yourBooks,
"members": members,
"n_members": n_members,
"security": bs,
"history": history,
"is_member": isMember
})
def remove_book(request, groupid):
"""
Django View. Remove book from the group.
@type request: C{django.http.HttpRequest}
@param request: Client Request object
@type groupid: C{string}
@param groupid: Unique group name
"""
if not request.GET.has_key("book"):
return pages.ErrorPage(request, "500.html")
book = models.Book.objects.get(url_title=request.GET["book"])
book.group = None
try:
book.save()
except:
transaction.rollback()
else:
transaction.commit()
try:
resp =HttpResponseRedirect(reverse("view_group", args=[groupid]))
except:
transaction.rollback()
raise
else:
transaction.commit()
return resp
def thumbnail_attachment(request, bookid, attachment, version=None):
"""
Returns image thumbnail for book attachment.
@param request: Django Request
@param bookid: Book ID
@param attachment: Attachment name
"""
from django.views import static
try:
book = models.Book.objects.get(url_title__iexact=bookid)
except models.Book.DoesNotExist:
return pages.ErrorPage(request, "errors/book_does_not_exist.html", {"book_name": bookid})
book_version = getVersion(book, version)
path = '%s/%s' % (book_version.getVersion(), attachment)
document_root = '%s/books/%s/%s' % (settings.DATA_ROOT, bookid, path)
# document_root = '%s/static/%s/%s' % (settings.STATIC_DOC_ROOT, bookid, path)
# should have one "broken image" in case of error
import Image
im = Image.open(document_root)
im.thumbnail((150, 150), Image.ANTIALIAS)
response = HttpResponse(mimetype='image/jpeg')
im.save(response, "jpeg")
return response
def staticattachment(request, bookid, attachment, version=None, chapter = None):
"""
Django View. Returns content of an attachment.
@todo: It is wrong in so many different levels to serve attachments this way.
@type request: C{django.http.HttpRequest}
@param request: Client Request object
@type bookid: C{string}
@param bookid: Unique Book ID
@type attachment: C{string}
@param attachment: Name of the attachment
@type version: C{string}
@param version: Version of the book
"""
from django.views import static
try:
book = models.Book.objects.get(url_title__iexact=bookid)
except models.Book.DoesNotExist:
return pages.ErrorPage(request, "errors/book_does_not_exist.html", {"book_name": bookid})
book_version = getVersion(book, version)
path = '%s/%s' % (book_version.getVersion(), attachment)
document_root = '%s/books/%s/' % (settings.DATA_ROOT, bookid)
return static.serve(request, path, document_root)
def add_book(request, groupid):
"""
Django View. Add new book to the group.
@type request: C{django.http.HttpRequest}
@param request: Client Request object
@type groupid: C{string}
@param groupid: Unique group name
"""
if not request.POST.has_key("book"):
return pages.ErrorPage(request, "500.html")
book = models.Book.objects.get(url_title=request.POST["book"])
group = models.BookiGroup.objects.get(url_name=groupid)
book.group = group
try:
book.save()
except:
transaction.rollback()
else:
transaction.commit()
return HttpResponseRedirect(reverse("view_group", args=[group.url_name]))
def export(request, bookid):
"""
Django View. Returns BookiZip file.
@param request: Django Request
@param bookid: Book ID.
"""
try:
book = models.Book.objects.get(url_title__iexact=bookid)
except models.Book.DoesNotExist:
return pages.ErrorPage(request, "errors/book_does_not_exist.html", {"book_name": bookid})
book_version = book.getVersion(None)
response = HttpResponse(mimetype='application/zip')
response['Content-Disposition'] = 'attachment; filename=%s.zip' % book.url_title
# this is not good
# should not do so much read/write in the memory
from booki.editor import common
fileName = common.exportBook(book_version)
response.write(open(fileName, 'rb').read())
import os
os.unlink(fileName)
return response
def view_profile(request, username):
"""
Django View. Shows user profile. Right now, this is just basics.
@type request: C{django.http.HttpRequest}
@param request: Django Request
@type username: C{string}
@param username: Username.
@todo: Check if user exists.
"""
from django.contrib.auth.models import User
from booki.editor import models
try:
user = User.objects.get(username=username)
except User.DoesNotExist:
return pages.ErrorPage(request, "errors/user_does_not_exist.html", {"username": username})
if request.user.username == username:
books = models.Book.objects.filter(owner=user)
else:
books = models.Book.objects.filter(owner=user, hidden=False)
groups = user.members.all()
return render_to_response('account/view_profile.html', {"request": request,
"user": user,
"books": books,
"groups": groups})
def book_cover(request, bookid, version=None):
"""
Return cover image for this book.
@todo: It is wrong in so many different levels to serve attachments this way.
@type request: C{django.http.HttpRequest}
@param request: Client Request object
@type bookid: C{string}
@param bookid: Unique Book ID
@type version: C{string}
@param version: Version of the book
"""
from django.views import static
try:
book = models.Book.objects.get(url_title__iexact=bookid)
except models.Book.DoesNotExist:
try:
resp = pages.ErrorPage(request, "errors/book_does_not_exist.html", {"book_name": bookid})
except:
transaction.rollback()
raise
else:
transaction.commit()
return resp
return static.serve(request, book.cover.name, settings.MEDIA_ROOT)
def book_chapter(request, bookid, chapter, version=None):
"""
Django View. Shows chapter for the published version of a book.
@type request: C{django.http.HttpRequest}
@param request: Client Request object
@type bookid: C{string}
@param bookid: Unique Book ID
@type chapter: C{string}
@param chapter: Chapter name
@type version: C{string}
@param verson: Book version
"""
try:
book = models.Book.objects.get(url_title__iexact=bookid)
except models.Book.DoesNotExist:
return pages.ErrorPage(request, "errors/book_does_not_exist.html", {"book_name": bookid})
book_version = getVersion(book, version)
chapters = []
for chap in models.BookToc.objects.filter(version=book_version).order_by("-weight"):
if chap.isChapter():
chapters.append({"url_title": chap.chapter.url_title,
"name": chap.chapter.title})
else:
chapters.append({"url_title": None,
"name": chap.name})
try:
content = models.Chapter.objects.get(version=book_version, url_title = chapter)
except models.Chapter.DoesNotExist:
return pages.ErrorPage(request, "errors/chapter_does_not_exist.html", {"chapter_name": chapter, "book": book})
except models.Chapter.MultipleObjectsReturned:
return pages.ErrorPage(request, "errors/chapter_duplicate.html", {"chapter_name": chapter, "book": book})
return render_to_response('reader/book_chapter.html', {"chapter": chapter,
"book": book,
"book_version": book_version.getVersion(),
"chapters": chapters,
"has_css": _customCSSExists(book.url_title),
"request": request,
"content": content})
def save_settings(request, username):
from django.contrib.auth.models import User
from booki.editor import models
try:
user = User.objects.get(username=username)
except User.DoesNotExist:
return pages.ErrorPage(request, "errors/user_does_not_exist.html",
{"username": username})
if request.user.username != username:
return HttpResponse("No, can't do!", "text/plain")
profile = user.get_profile()
user.email = request.POST.get('email', '')
user.first_name = request.POST.get('fullname', '')
user.save()
profile.description = request.POST.get('aboutyourself', '')
if request.FILES.has_key('profile'):
from booki.utils import misc
# Check for any kind of error at the moment.
# Notify user later with different messages.
try:
misc.setProfileImage(user, request.FILES['profile'])
except:
pass
try:
profile.save()
endpoint_config = get_endpoint_or_none("@" +
user.username).get_config()
endpoint_config.notification_filter = request.POST.get(
'notification', '')
endpoint_config.save()
except:
# Should set some error code here
transaction.rollback()
else:
transaction.commit()
try:
resp = HttpResponse(
'<html><head><script>var j = parent.jQuery; j(function() { j.booki.profile.reloadProfileInfo(); });</script></head></html>',
'text/html')
except:
transaction.rollback()
raise
else:
transaction.commit()
return resp
def edit_info(request, bookid, version=None):
"""
Django View.
@type request: C{django.http.HttpRequest}
@param request: Client Request object
@type bookid: C{string}
@param bookid: Unique Book ID
@type version: C{string}
@param verson: Book version
"""
try:
book = models.Book.objects.get(url_title__iexact=bookid)
except models.Book.DoesNotExist:
return pages.ErrorPage(request, "errors/book_does_not_exist.html",
{"book_name": bookid})
book_version = book.getVersion(version)
if request.method == 'POST':
book.description = request.POST.get('description', '')
if request.FILES.has_key('cover'):
from booki.utils import misc
import os
try:
fh, fname = misc.saveUploadedAsFile(request.FILES['cover'])
book.setCover(fname)
os.unlink(fname)
except:
pass
try:
book.save()
return render_to_response('reader/edit_info_redirect.html', {
"request": request,
"book": book
})
except:
transaction.rollback()
finally:
transaction.commit()
try:
return render_to_response('reader/edit_info.html', {
"request": request,
"book": book
})
except:
transaction.rollback()
finally:
transaction.commit()
def upload_attachment(request, bookid, version=None):
"""
Uploades attachments. Used from Upload dialog.
@param request: Django Request
@param bookid: Book ID
@param version: Book version or None
"""
try:
book = models.Book.objects.get(url_title__iexact=bookid)
except models.Book.DoesNotExist:
return pages.ErrorPage(request, "errors/book_does_not_exist.html", {"book_name": bookid})
book_version = getVersion(book, version)
stat = models.BookStatus.objects.filter(book = book)[0]
# check this for transactions
for name, fileData in request.FILES.items():
from booki.utils import log
log.logBookHistory(book = book,
version = book_version,
args = {'filename': request.FILES[name].name},
user = request.user,
kind = 'attachment_upload')
att = models.Attachment(version = book_version,
# must remove this reference
book = book,
status = stat)
att.save()
att.attachment.save(request.FILES[name].name, fileData, save = False)
att.save()
# TODO:
# must write info about this to log!
# maybe check file name now and save with new name
transaction.commit()
if request.POST.get("attachmenttab", "") == "":
return HttpResponse('<html><body><script> parent.closeAttachmentUpload(); </script></body></html>')
# should not call showAttachmentsTab, but it works for now
return HttpResponse('<html><body><script> parent.jQuery.booki.editor.showAttachmentsTab(); parent.jQuery("#tabattachments FORM")[0].reset(); </script></body></html>')
def view_profile(request, username):
"""
Django View. Shows user profile. Right now, this is just basics.
@type request: C{django.http.HttpRequest}
@param request: Django Request
@type username: C{string}
@param username: Username.
@todo: Check if user exists.
"""
from django.contrib.auth.models import User
from booki.editor import models
try:
user = User.objects.get(username=username)
except User.DoesNotExist:
return pages.ErrorPage(request, "errors/user_does_not_exist.html", {"username": username})
if request.user.username == username:
books = models.Book.objects.filter(owner=user)
else:
if request.user.is_authenticated() and request.user.is_superuser:
books = models.Book.objects.filter(owner=user)
else:
books = models.Book.objects.filter(owner=user, hidden=False)
groups = user.members.all()
from django.utils.html import escape
userDescription = escape(user.get_profile().description)
admin_create = config.getConfiguration('ADMIN_CREATE_BOOKS')
admin_import = config.getConfiguration('ADMIN_IMPORT_BOOKS')
if request.user.is_superuser:
admin_create = False
admin_import = False
return render_to_response('account/view_profile.html', {"request": request,
"user": user,
"admin_create": admin_create,
"admin_import": admin_import,
"user_description": '<br/>'.join(userDescription.replace('\r','').split('\n')),
"books": books,
"groups": groups})
def my_people (request, username):
"""
Django View. Shows nothing at the moment.
@type request: C{django.http.HttpRequest}
@param request: Django Request
@type username: C{string}
@param username: Username.
"""
from django.contrib.auth.models import User
try:
user = User.objects.get(username=username)
except User.DoesNotExist:
return pages.ErrorPage(request, "errors/user_does_not_exist.html", {"username": username})
return render_to_response('account/my_people.html', {"request": request,
"user": user})
def view_profilethumbnail(request, profileid):
"""
Django View. Shows user profile image.
@type request: C{django.http.HttpRequest}
@param request: Django Request
@type profileid: C{string}
@param profileid: Username.
@todo: Check if user exists.
"""
from django.http import HttpResponse
from django.contrib.auth.models import User
try:
u = User.objects.get(username=profileid)
except User.DoesNotExist:
return pages.ErrorPage(request, "errors/user_does_not_exist.html", {"username": username})
# this should be a seperate function
if not u.get_profile().image:
try:
name = '%s/images/%s' % (settings.STATIC_ROOT, settings.DEFAULT_PROFILE_IMAGE)
except AttributeError:
name = '%s%s' % (settings.SITE_STATIC_ROOT, '/images/anonymous.jpg')
else:
name = u.get_profile().image.path
import Image
image = Image.open(name)
image.thumbnail((int(request.GET.get('width', 24)), int(request.GET.get('width', 24))), Image.ANTIALIAS)
# serialize to HTTP response
response = HttpResponse(mimetype="image/jpg")
image.save(response, "JPEG")
return response
def book_info(request, bookid, version=None):
"""
Django View. Shows single page with all the Book info.
@type request: C{django.http.HttpRequest}
@param request: Client Request object
@type bookid: C{string}
@param bookid: Unique Book ID
@type version: C{string}
@param verson: Book version
"""
try:
book = models.Book.objects.get(url_title__iexact=bookid)
except models.Book.DoesNotExist:
return pages.ErrorPage(request, "errors/book_does_not_exist.html", {"book_name": bookid})
book_version = getVersion(book, version)
book_history = models.BookHistory.objects.filter(version = book_version).order_by("-modified")[:20]
book_collaborators = [e.values()[0] for e in models.BookHistory.objects.filter(version = book_version, kind = 2).values("user__username").distinct()]
import sputnik
channel_name = "/booki/book/%s/%s/" % (book.id, book_version.getVersion())
online_users = sputnik.smembers("sputnik:channel:%s:users" % channel_name)
book_versions = models.BookVersion.objects.filter(book=book).order_by("created")
return render_to_response('reader/book_info.html', {"book": book,
"book_version": book_version.getVersion(),
"book_versions": book_versions,
"book_history": book_history,
"book_collaborators": book_collaborators,
"has_css": _customCSSExists(book.url_title),
"online_users": online_users,
"request": request})
def attachment(request, bookid, attachment, version=None):
"""
Django View. Returns content of an attachment.
@todo: Not sure if this is even used anymore
@type request: C{django.http.HttpRequest}
@param request: Client Request object
@type bookid: C{string}
@param bookid: Unique Book ID
@type attachment: C{string}
@param attachment: Name of the attachment
@type version: C{string}
@param version: Version of the book
"""
from django.views import static
try:
book = models.Book.objects.get(url_title__iexact=bookid)
except models.Book.DoesNotExist:
try:
resp = pages.ErrorPage(request, "errors/book_does_not_exist.html", {"book_name": bookid})
except:
transaction.rollback()
raise
else:
transaction.commit()
return resp
book_version = book.getVersion(version)
path = '%s/%s' % (version, attachment)
document_root = '%s/books/%s/' % (settings.DATA_ROOT, bookid)
return static.serve(request, path, document_root)
def my_groups (request, username):
"""
Django View. Show user groups.
@type request: C{django.http.HttpRequest}
@param request: Django Request
@type username: C{string}
@param username: Username.
"""
from django.contrib.auth.models import User
try:
user = User.objects.get(username=username)
except User.DoesNotExist:
return pages.ErrorPage(request, "errors/user_does_not_exist.html", {"username": username})
groups = user.members.all()
return render_to_response('account/my_groups.html', {"request": request,
"user": user,
"groups": groups,})
def create_book(request, username):
"""
Django View. Show content for Create Book dialog and creates book.
@type request: C{django.http.HttpRequest}
@param request: Django Request
@type username: C{string}
@param username: Username.
"""
from django.contrib.auth.models import User
from booki.utils.misc import isBookLimitReached
try:
user = User.objects.get(username=username)
except User.DoesNotExist:
try:
resp = pages.ErrorPage(request, "errors/user_does_not_exist.html",
{"username": username})
except:
transaction.rollback()
raise
else:
transaction.commit()
return resp
if isBookLimitReached() or not request.user.is_authenticated():
try:
resp = pages.ErrorPage(request, "errors/no_permissions.html")
except:
transaction.rollback()
raise
else:
transaction.commit()
return resp
from booki.utils.book import checkBookAvailability, createBook
from booki.editor import models
book_visible = config.getConfiguration('CREATE_BOOK_VISIBLE')
book_license = config.getConfiguration('CREATE_BOOK_LICENSE')
admin_create = config.getConfiguration('ADMIN_CREATE_BOOKS')
if request.user.is_superuser:
admin_create = False
if request.GET.get("q", "") == "check":
from booki.utils.json_wrapper import json
data = {
"available":
checkBookAvailability(request.GET.get('bookname', '').strip())
}
try:
resp = HttpResponse(json.dumps(data), "text/plain")
except:
transaction.rollback()
raise
else:
transaction.commit()
return resp
if request.method == 'POST' and admin_create == False:
book = None
try:
# hidden on
# description
# license
# title
# cover
book = createBook(request.user, request.POST.get('title'))
lic = models.License.objects.get(
abbrevation=request.POST.get('license'))
book.license = lic
book.description = request.POST.get('description', '')
if request.POST.get("hidden", "") == "on":
is_hidden = True
else:
is_hidden = False
book.hidden = is_hidden
from django.core.files import File
if request.FILES.has_key('cover'):
# TODO: Show some kind of error message to the user
from booki.utils import misc
import os
try:
fh, fname = misc.saveUploadedAsFile(request.FILES['cover'])
book.setCover(fname)
os.unlink(fname)
except:
pass
book.save()
except:
transaction.rollback()
else:
transaction.commit()
try:
resp = render_to_response('account/create_book_redirect.html', {
"request": request,
"user": user,
"book": book
})
except:
transaction.rollback()
raise
else:
transaction.commit()
return resp
from booki.editor.models import License
licenses = License.objects.all().order_by('name')
try:
resp = render_to_response(
'account/create_book.html', {
"request": request,
"book_visible": book_visible,
"book_license": book_license,
"admin_create": admin_create,
"licenses": licenses,
"user": user
})
except:
transaction.rollback()
raise
else:
transaction.commit()
return resp
def view_profilethumbnail(request, profileid):
"""
Django View. Shows user profile image.
@type request: C{django.http.HttpRequest}
@param request: Django Request
@type profileid: C{string}
@param profileid: Username.
@todo: Check if user exists.
"""
from django.http import HttpResponse
from django.contrib.auth.models import User
try:
u = User.objects.get(username=profileid)
except User.DoesNotExist:
try:
resp = pages.ErrorPage(request, "errors/user_does_not_exist.html",
{"username": profileid})
except:
transaction.rollback()
raise
else:
transaction.commit()
return resp
name = ''
def _getDefaultProfile():
"Return path to default profile image."
try:
name = '%s/images/%s' % (settings.STATIC_ROOT,
settings.DEFAULT_PROFILE_IMAGE)
except AttributeError:
name = '%s%s' % (settings.SITE_STATIC_ROOT,
'/images/anonymous.png')
return name
# this should be a seperate function
if not u.get_profile().image:
name = _getDefaultProfile()
else:
name = u.get_profile().image.path
import Image
try:
image = Image.open(name)
except IOError:
image = Image.open(_getDefaultProfile())
image.thumbnail(
(int(request.GET.get('width', 24)), int(request.GET.get('width', 24))),
Image.ANTIALIAS)
# serialize to HTTP response
# this could throw exception if PIL does not have support for jpeg
try:
response = HttpResponse(mimetype="image/jpg")
image.save(response, "JPEG")
except:
transaction.rollback()
raise
else:
transaction.commit()
return response
def my_books (request, username):
"""
Django View. Show user books.
@type request: C{django.http.HttpRequest}
@param request: Django Request
@type username: C{string}
@param username: Username.
"""
from django.contrib.auth.models import User
from booki.editor import models
try:
user = User.objects.get(username=username)
except User.DoesNotExist:
return pages.ErrorPage(request, "errors/user_does_not_exist.html", {"username": username})
books = models.Book.objects.filter(owner=user)
if request.POST.get("action") == "hide":
book = models.Book.objects.get(url_title=request.POST.get("book"))
book.hidden = True
book.save()
transaction.commit()
elif request.POST.get("action") == "unhide":
book = models.Book.objects.get(url_title=request.POST.get("book"))
book.hidden = False
book.save()
transaction.commit()
if request.method == 'POST' and not request.POST.get("action"):
project_form = BookForm(request.POST)
import_form = ImportForm(request.POST)
if import_form.is_valid() and import_form.cleaned_data["id"]:
project_form = BookForm() # reset the other form
try:
ID = import_form.cleaned_data["id"]
import_type = import_form.cleaned_data["type"]
rename_title = import_form.cleaned_data["rename_title"]
extraOptions = {}
if rename_title:
extraOptions['book_title'] = rename_title
if import_form.cleaned_data["hidden"]:
extraOptions['hidden'] = True
import_sources = { # base_url source=
'flossmanuals': (TWIKI_GATEWAY_URL, "en.flossmanuals.net"),
"archive": (ESPRI_URL, "archive.org"),
"wikibooks": (ESPRI_URL, "wikibooks"),
"epub": (ESPRI_URL, "url"),
}
if import_type == "booki":
ID = ID.rstrip("/")
booki_url, book_url_title = ID.rsplit("/", 1)
base_url = "%s/export/%s/export" % (booki_url, book_url_title)
source = "booki"
else:
base_url, source = import_sources[import_type]
common.importBookFromUrl2(user, base_url,
args=dict(source=source,
book=ID),
**extraOptions
)
except Exception:
transaction.rollback()
logError(traceback.format_exc())
return render_to_response('account/error_import.html',
{"request": request, "user": user})
else:
transaction.commit()
#XXX should this be elif? even if the POST is valid as both forms, the
# transaction will end up being commited twice.
if project_form.is_valid() and project_form.cleaned_data["title"]:
import_form = ImportForm() # reset the other form
from booki.utils.book import createBook
title = project_form.cleaned_data["title"]
try:
book = createBook(user, title)
license = project_form.cleaned_data["license"]
lic = models.License.objects.get(abbrevation=license)
book.license = lic
book.hidden = project_form.cleaned_data["hidden"]
book.save()
except:
transaction.rollback()
else:
transaction.commit()
return HttpResponseRedirect(reverse("my_books", args=[username]))
else:
project_form = BookForm()
import_form = ImportForm()
try:
return render_to_response('account/my_books.html', {"request": request,
"user": user,
"project_form": project_form,
"import_form": import_form,
"books": books,})
except:
transaction.rollback()
finally:
transaction.commit()
def book_delete(request, bookid, version=None):
"""
Django View.
@type request: C{django.http.HttpRequest}
@param request: Client Request object
@type bookid: C{string}
@param bookid: Unique Book ID
@type version: C{string}
@param verson: Book version
"""
try:
book = models.Book.objects.get(url_title__iexact=bookid)
except models.Book.DoesNotExist:
try:
resp = pages.ErrorPage(request, "errors/book_does_not_exist.html", {"book_name": bookid})
except:
transaction.rollback()
raise
else:
transaction.commit()
return resp
book_version = book.getVersion(version)
if request.method == 'POST':
title = request.POST.get('title', '')
try:
from booki.utils import security
bookSecurity = security.getUserSecurityForBook(request.user, book)
resp = render_to_response('reader/book_delete_error.html', {"request": request})
if bookSecurity.isAdmin():
if title.strip() == book.title.strip():
from booki.utils.book import removeBook
removeBook(book)
resp = render_to_response('reader/book_delete_redirect.html', {"request": request})
except:
transaction.rollback()
raise
else:
transaction.commit()
return resp
try:
resp = render_to_response('reader/book_delete.html', {"request": request,
"book": book})
except:
transaction.rollback()
raise
else:
transaction.commit()
return resp
def book_chapter(request, bookid, chapter, version=None):
"""
Django View. Shows chapter for the published version of a book.
@type request: C{django.http.HttpRequest}
@param request: Client Request object
@type bookid: C{string}
@param bookid: Unique Book ID
@type chapter: C{string}
@param chapter: Chapter name
@type version: C{string}
@param verson: Book version
"""
try:
book = models.Book.objects.get(url_title__iexact=bookid)
except models.Book.DoesNotExist:
try:
resp = pages.ErrorPage(request, "errors/book_does_not_exist.html", {"book_name": bookid})
except:
transaction.rollback()
raise
else:
transaction.commit()
return resp
book_version = book.getVersion(version)
from booki.utils import security
bookSecurity = security.getUserSecurityForBook(request.user, book)
hasPermission = security.canEditBook(book, bookSecurity)
if book.hidden and not hasPermission:
try:
resp = pages.ErrorPage(request, "errors/no_permissions.html")
except:
transaction.rollback()
raise
else:
transaction.commit()
return resp
chapters = []
for chap in models.BookToc.objects.filter(version=book_version).order_by("-weight"):
if chap.isChapter():
chapters.append({"url_title": chap.chapter.url_title,
"name": chap.chapter.title})
else:
chapters.append({"url_title": None,
"name": chap.name})
try:
content = models.Chapter.objects.get(version=book_version, url_title = chapter)
except models.Chapter.DoesNotExist:
try:
resp = pages.ErrorPage(request, "errors/chapter_does_not_exist.html", {"chapter_name": chapter, "book": book})
except:
transaction.rollback()
raise
else:
transaction.commit()
return resp
except models.Chapter.MultipleObjectsReturned:
try:
resp = pages.ErrorPage(request, "errors/chapter_duplicate.html", {"chapter_name": chapter, "book": book})
except:
transaction.rollback()
raise
else:
transaction.commit()
try:
resp = render_to_response('reader/book_chapter.html', {"chapter": chapter,
"book": book,
"book_version": book_version.getVersion(),
"chapters": chapters,
"has_css": _customCSSExists(book.url_title),
"request": request,
"content": content})
except:
transaction.rollback()
else:
transaction.commit()
return resp
def create_group(request, username):
"""
Django View. Show content for Create Group dialog and creates group.
@type request: C{django.http.HttpRequest}
@param request: Django Request
@type username: C{string}
@param username: Username.
"""
from django.contrib.auth.models import User
try:
user = User.objects.get(username=username)
except User.DoesNotExist:
try:
resp = pages.ErrorPage(request, "errors/user_does_not_exist.html",
{"username": username})
except:
transaction.rollback()
raise
else:
transaction.commit()
return resp
if not request.user.is_authenticated():
try:
resp = pages.ErrorPage(request, "errors/no_permissions.html")
except:
transaction.rollback()
raise
else:
transaction.commit()
return resp
from booki.utils.book import checkGroupAvailability, createBookiGroup
from booki.editor import models
if request.GET.get("q", "") == "check":
from booki.utils.json_wrapper import json
data = {
"available":
checkGroupAvailability(request.GET.get('groupname', '').strip())
}
try:
resp = HttpResponse(json.dumps(data), "text/plain")
except:
transaction.rollback()
raise
else:
transaction.commit()
return resp
if request.GET.get("q", "") == "create":
from booki.utils.json_wrapper import json
groupName = request.GET.get('name', '').strip()
groupDescription = request.GET.get('description', '').strip()
groupCreated = False
if checkGroupAvailability(groupName):
try:
group = createBookiGroup(groupName, groupDescription,
request.user)
group.members.add(request.user)
groupCreated = True
except BookiGroupExist:
groupCreated = False
transaction.rollback()
else:
transaction.commit()
data = {'created': groupCreated}
try:
resp = HttpResponse(json.dumps(data), "text/plain")
except:
transaction.rollback()
raise
else:
transaction.commit()
return resp
try:
resp = render_to_response('account/create_group.html', {
"request": request,
"user": user
})
except:
transaction.rollback()
raise
else:
transaction.commit()
return resp
def book_info(request, bookid, version=None):
"""
Django View. Shows single page with all the Book info.
@type request: C{django.http.HttpRequest}
@param request: Client Request object
@type bookid: C{string}
@param bookid: Unique Book ID
@type version: C{string}
@param verson: Book version
"""
try:
book = models.Book.objects.get(url_title__iexact=bookid)
except models.Book.DoesNotExist:
try:
resp = pages.ErrorPage(request, "errors/book_does_not_exist.html", {"book_name": bookid})
except:
transaction.rollback()
raise
else:
transaction.commit()
return resp
book_version = book.getVersion(version)
book_history = models.BookHistory.objects.filter(version = book_version).order_by("-modified")[:20]
book_collaborators = [e.values()[0] for e in models.BookHistory.objects.filter(version = book_version, kind = 2).values("user__username").distinct()]
from booki.utils import security
bookSecurity = security.getUserSecurityForBook(request.user, book)
isBookAdmin = bookSecurity.isAdmin()
import sputnik
channel_name = "/booki/book/%s/%s/" % (book.id, book_version.getVersion())
online_users = sputnik.smembers("sputnik:channel:%s:users" % channel_name)
book_versions = models.BookVersion.objects.filter(book=book).order_by("created")
from django.utils.html import escape
bookDescription = escape(book.description)
try:
resp = render_to_response('reader/book_info.html', {"book": book,
"book_version": book_version.getVersion(),
"book_versions": book_versions,
"book_history": book_history,
"book_collaborators": book_collaborators,
"has_css": _customCSSExists(book.url_title),
"is_book_admin": isBookAdmin,
"online_users": online_users,
"book_description": '<br/>'.join(bookDescription.replace('\r','').split('\n')),
"request": request})
except:
transaction.rollback()
raise
else:
transaction.commit()
return resp
def import_book(request, username):
"""
Django View. Book Import dialog.
@type request: C{django.http.HttpRequest}
@param request: Django Request
@type username: C{string}
@param username: Username.
"""
from django.contrib.auth.models import User
from booki.utils.misc import isBookLimitReached
try:
user = User.objects.get(username=username)
except User.DoesNotExist:
try:
resp = pages.ErrorPage(request, "errors/user_does_not_exist.html",
{"username": username})
except:
transaction.rollback()
raise
else:
transaction.commit()
return resp
if isBookLimitReached() or not request.user.is_authenticated():
try:
resp = pages.ErrorPage(request, "errors/no_permissions.html")
except:
transaction.rollback()
raise
else:
transaction.commit()
return resp
from booki.utils.book import checkGroupAvailability, createBookiGroup
from booki.editor import models
if request.GET.get("q", "") == "check":
from booki.utils.json_wrapper import json
data = {
"available":
checkGroupAvailability(request.GET.get('groupname', '').strip())
}
try:
resp = HttpResponse(json.dumps(data), "text/plain")
except:
transaction.rollback()
raise
else:
transaction.commit()
return resp
book_visible = config.getConfiguration('CREATE_BOOK_VISIBLE')
admin_import = config.getConfiguration('ADMIN_IMPORT_BOOKS')
if request.user.is_superuser:
admin_import = False
if request.GET.get("q", "") == "import" and admin_import == False:
from booki.utils.json_wrapper import json
data = {}
try:
bookid = request.GET.get('source', '')
importType = request.GET.get('importtype', '')
renameTitle = request.GET.get('title', '')
extraOptions = {}
if renameTitle:
extraOptions['book_title'] = renameTitle
if request.GET.get('hidden', '') != '':
extraOptions['hidden'] = True
ESPRI_URL = config.getConfiguration('ESPRI_URL')
importSources = {
"archive": (ESPRI_URL, "archive.org"),
"wikibooks": (ESPRI_URL, "wikibooks"),
"epub": (ESPRI_URL, "url"),
}
if importType == "booki":
bookid = bookid.rstrip('/')
booki_url, book_url_title = bookid.rsplit("/", 1)
base_url = "%s/export/%s/export" % (booki_url, book_url_title)
source = "booki"
else:
base_url, source = importSources[importType]
book = common.importBookFromUrl2(user,
base_url,
args=dict(source=source,
book=bookid),
**extraOptions)
except Exception:
data['imported'] = False
transaction.rollback()
else:
transaction.commit()
data['imported'] = True
from django.core.urlresolvers import reverse
data['info_url'] = reverse('book_info', args=[book.url_title])
try:
resp = HttpResponse(json.dumps(data), "text/plain")
except:
transaction.rollback()
raise
else:
transaction.commit()
return resp
try:
resp = render_to_response(
'account/import_book.html', {
"request": request,
"book_visible": book_visible,
"admin_import": admin_import,
"user": user
})
except:
transaction.rollback()
raise
else:
transaction.commit()
return resp
def draft_book(request, bookid, version=None):
"""
Django View. Shows main page for the draft version of a book.
@type request: C{django.http.HttpRequest}
@param request: Client Request object
@type bookid: C{string}
@param bookid: Unique Book ID
@type version: C{string}
@param verson: Book version
"""
try:
book = models.Book.objects.get(url_title__iexact=bookid)
except models.Book.DoesNotExist:
try:
resp = pages.ErrorPage(request, "errors/book_does_not_exist.html", {"book_name": bookid})
except:
transaction.rollback()
raise
else:
transaction.commit()
return resp
book_version = book.getVersion(version)
from booki.utils import security
bookSecurity = security.getUserSecurityForBook(request.user, book)
hasPermission = security.canEditBook(book, bookSecurity)
if book.hidden and not hasPermission:
try:
resp = pages.ErrorPage(request, "errors/no_permissions.html")
except:
transaction.rollback()
raise
else:
transaction.commit()
return resp
chapters = []
firstChapter = None
for chapter in models.BookToc.objects.filter(version=book_version).order_by("-weight"):
if chapter.isChapter():
if not firstChapter:
firstChapter = chapter.chapter
chapters.append({"url_title": chapter.chapter.url_title,
"name": chapter.chapter.title})
else:
chapters.append({"url_title": None,
"name": chapter.name})
try:
editingEnabled = False
if request.user.is_authenticated() and book.version == book_version:
editingEnabled = True
if firstChapter:
resp = redirect('draft_chapter', bookid = book.url_title, version=book_version.getVersion(), chapter=firstChapter.url_title)
else:
resp = render_to_response('reader/draft_book.html', {"book": book,
"book_version": book_version.getVersion(),
"chapters": chapters,
"editing_enabled": editingEnabled,
"has_css": _customCSSExists(book.url_title),
"request": request})
except:
transaction.rollback()
raise
else:
transaction.commit()
return resp
