__doc__ = "Module documentation."
from piston.handler import BaseHandler, AnonymousBaseHandler
+from django.http import HttpResponse
-import re
from datetime import date
from django.core.urlresolvers import reverse
-from django.utils import simplejson as json
from django.db import IntegrityError
import librarian
import librarian.html
+import difflib
from librarian import dcparser, parser
from wlrepo import *
import api.forms as forms
import api.response as response
from api.utils import validate_form, hglibrary, natural_order
-from api.models import PartCache
+from api.models import PartCache, PullRequest
#
import settings
def is_prq(username):
return username.startswith('$prq-')
+def prq_for_user(username):
+ try:
+ return PullRequest.objects.get(id=int(username[5:]))
+ except:
+ return None
+
def check_user(request, user):
log.info("user: %r, perm: %r" % (request.user, request.user.get_all_permissions()) )
#pull request
if is_prq(user):
- if not request.user.has_perm('api.pullrequest.can_view'):
+ if not request.user.has_perm('api.view_prq'):
yield response.AccessDenied().django_response({
'reason': 'access-denied',
'message': "You don't have enough priviliges to view pull requests."
})
# other users
elif request.user.username != user:
- if not request.user.has_perm('api.document.can_view_other'):
+ if not request.user.has_perm('api.view_other_document'):
yield response.AccessDenied().django_response({
'reason': 'access-denied',
'message': "You don't have enough priviliges to view other people's document."
log.info("DOCID %s", docid)
doc = lib.document_create(docid)
# document created, but no content yet
-
try:
doc = doc.quickwrite('xml', data.encode('utf-8'),
'$AUTO$ XML data uploaded.', user=request.user.username)
return result
+
+class DiffHandler(BaseHandler):
+ allowed_methods = ('GET',)
+
+ @hglibrary
+ def read(self, request, source_revision, target_revision, lib):
+ '''Return diff between source_revision and target_revision)'''
+ source_document = lib.document_for_rev(source_revision)
+ target_document = lib.document_for_rev(target_revision)
+ print source_document,
+ print target_document
+ diff = difflib.unified_diff(
+ source_document.data('xml').splitlines(True),
+ target_document.data('xml').splitlines(True),
+ 'source',
+ 'target')
+
+ return ''.join(list(diff))
+
+
#
# Document Meta Data
#
# the user doesn't have this document checked out
# or some other weird error occured
# try to do the checkout
- if is_prq(user) or (user == request.user.username):
- try:
+ try:
+ if user == request.user.username:
mdoc = lib.document(docid)
doc = mdoc.take(user)
-
- if is_prq(user):
- # source revision, should probably change
- # but there are no changes yet, so...
- pass
-
- except RevisionNotFound, e:
+ elif is_prq(user):
+ prq = prq_for_user(user)
+ # commiter's document
+ prq_doc = lib.document_for_rev(prq.source_revision)
+ doc = prq_doc.take(user)
+ else:
return response.EntityNotFound().django_response({
'reason': 'document-not-found',
'message': e.message,
- 'docid': docid
+ 'docid': docid,
+ 'user': user,
})
- else:
+ except RevisionNotFound, e:
return response.EntityNotFound().django_response({
'reason': 'document-not-found',
'message': e.message,
'docid': docid,
- 'user': user,
+ 'user': user
})
return {
return error
return librarian.html.transform(document.data('xml'), is_file=False, \
- parse_dublincore=False, stylesheet=stylesheet,\
+ parse_dublincore=False, stylesheet='full',\
options={
"with-paths": 'boolean(1)',
})
except (EntryNotFound, RevisionNotFound), e:
return response.EntityNotFound().django_response({
'reason': 'not-found', 'message': e.message})
+ except librarian.ValidationError, e:
+ return response.InternalError().django_response({
+ 'reason': 'xml-non-valid', 'message': e.message })
except librarian.ParseError, e:
return response.InternalError().django_response({
'reason': 'xml-parse-error', 'message': e.message })
gallery = {'name': assoc.name, 'pages': []}
- for file in sorted(os.listdir(dirpath)):
+ for file in os.listdir(dirpath):
if not isinstance(file, unicode):
try:
file = file.decode('utf-8')
# gallery['pages'].sort()
galleries.append(gallery)
- return galleries
-
-#
-# Document Text View
-#
+ return galleries
-XINCLUDE_REGEXP = r"""<(?:\w+:)?include\s+[^>]*?href=("|')wlrepo://(?P<link>[^\1]+?)\1\s*[^>]*?>"""
-#
-#
-#
-
-class DocumentTextHandler(BaseHandler):
- allowed_methods = ('GET', 'POST')
-
- @validate_form(forms.TextRetrieveForm, 'GET')
- @hglibrary
- def read(self, request, form, docid, lib):
- """Read document as raw text"""
- try:
- revision = form.cleaned_data['revision']
- part = form.cleaned_data['part']
- user = form.cleaned_data['user'] or request.user.username
-
- document = lib.document_for_rev(revision)
-
- if document.id != docid:
- return response.BadRequest().django_response({
- 'reason': 'name-mismatch',
- 'message': 'Provided revision is not valid for this document'
- })
-
- if document.owner != user:
- return response.BadRequest().django_response({
- 'reason': 'user-mismatch',
- 'message': "Provided revision doesn't belong to user %s" % user
- })
-
- for error in check_user(request, user):
- return error
-
- if not part:
- return document.data('xml')
-
- xdoc = parser.WLDocument.from_string(document.data('xml'),\
- parse_dublincore=False)
- ptext = xdoc.part_as_text(part)
-
- if ptext is None:
- return response.EntityNotFound().django_response({
- 'reason': 'no-part-in-document'
- })
-
- return ptext
- except librarian.ParseError, e:
- return response.EntityNotFound().django_response({
- 'reason': 'invalid-document-state',
- 'exception': type(e),
- 'message': e.message
- })
- except (EntryNotFound, RevisionNotFound), e:
- return response.EntityNotFound().django_response({
- 'reason': 'not-found',
- 'exception': type(e), 'message': e.message
- })
-
- @validate_form(forms.TextUpdateForm, 'POST')
- @hglibrary
- def create(self, request, form, docid, lib):
- try:
- revision = form.cleaned_data['revision']
- msg = form.cleaned_data['message']
- user = form.cleaned_data['user'] or request.user.username
-
- # do not allow changing not owned documents
- # (for now... )
-
-
- if user != request.user.username:
- return response.AccessDenied().django_response({
- 'reason': 'insufficient-priviliges',
- })
-
- current = lib.document(docid, user)
- orig = lib.document_for_rev(revision)
-
- if current != orig:
- return response.EntityConflict().django_response({
- "reason": "out-of-date",
- "provided_revision": orig.revision,
- "latest_revision": current.revision })
-
- if form.cleaned_data.has_key('contents'):
- data = form.cleaned_data['contents']
- else:
- chunks = form.cleaned_data['chunks']
- xdoc = parser.WLDocument.from_string(current.data('xml'))
- errors = xdoc.merge_chunks(chunks)
-
- if len(errors):
- return response.EntityConflict().django_response({
- "reason": "invalid-chunks",
- "message": "Unable to merge following parts into the document: %s " % ",".join(errors)
- })
-
- data = xdoc.serialize()
-
- # try to find any Xinclude tags
- includes = [m.groupdict()['link'] for m in (re.finditer(\
- XINCLUDE_REGEXP, data, flags=re.UNICODE) or []) ]
-
- log.info("INCLUDES: %s", includes)
-
- # TODO: provide useful routines to make this simpler
- def xml_update_action(lib, resolve):
- try:
- f = lib._fileopen(resolve('parts'), 'r')
- stored_includes = json.loads(f.read())
- f.close()
- except:
- stored_includes = []
-
- if stored_includes != includes:
- f = lib._fileopen(resolve('parts'), 'w+')
- f.write(json.dumps(includes))
- f.close()
-
- lib._fileadd(resolve('parts'))
-
- # update the parts cache
- PartCache.update_cache(docid, current.owner,\
- stored_includes, includes)
-
- # now that the parts are ok, write xml
- f = lib._fileopen(resolve('xml'), 'w+')
- f.write(data.encode('utf-8'))
- f.close()
-
- ndoc = None
- ndoc = current.invoke_and_commit(\
- xml_update_action, lambda d: (msg, user) )
-
- try:
- # return the new revision number
- return response.SuccessAllOk().django_response({
- "document": ndoc.id,
- "user": user,
- "subview": "xml",
- "previous_revision": current.revision,
- "revision": ndoc.revision,
- 'timestamp': ndoc.revision.timestamp,
- "url": reverse("doctext_view", args=[ndoc.id])
- })
- except Exception, e:
- if ndoc: lib._rollback()
- raise e
- except RevisionNotFound, e:
- return response.EntityNotFound(mimetype="text/plain").\
- django_response(e.message)
#
if form.cleaned_data['type'] == 'update':
# update is always performed from the file branch
# to the user branch
- changed, clean = base_doc.update(request.user.username)
+ user_doc_new = base_doc.update(request.user.username)
- # update user document
- if changed:
- user_doc_new = user_doc.latest()
- else:
- user_doc_new = user_doc
+ if user_doc_new == user_doc:
+ return response.SuccessAllOk().django_response({
+ "result": "no-op"
+ })
# shared document is the same
doc_new = doc
if not base_doc.up_to_date():
return response.BadRequest().django_response({
"reason": "not-fast-forward",
- "message": "You must first update yout branch to the latest version."
+ "message": "You must first update your branch to the latest version."
+ })
+
+ if base_doc.parentof(doc) or base_doc.has_parent_from(doc):
+ return response.SuccessAllOk().django_response({
+ "result": "no-op"
})
# check for unresolved conflicts
if base_doc.has_conflict_marks():
- return response.BadRequest().django_response({
+ return response.BadRequest().django_response({
"reason": "unresolved-conflicts",
"message": "There are unresolved conflicts in your file. Fix them, and try again."
})
- if not request.user.has_perm('api.document.can_share'):
+ if not request.user.has_perm('api.share_document'):
# User is not permitted to make a merge, right away
# So we instead create a pull request in the database
try:
# Same goes for shared view
return response.SuccessAllOk().django_response({
+ "result": "success",
"name": user_doc_new.id,
"user": user_doc_new.owner,
"revision": user_doc_new.revision,
'timestamp': user_doc_new.revision.timestamp,
- "parent_revision": user_doc_new.revision,
- "parent_timestamp": user_doc_new.revision.timestamp,
+ "parent_revision": user_doc.revision,
+ "parent_timestamp": user_doc.revision.timestamp,
"shared_revision": doc_new.revision,
"shared_timestamp": doc_new.revision.timestamp,
fnp / redakcja.git / blobdiff