1 # -*- coding: utf-8 -*-
2 from datetime import datetime
8 from django.conf import settings
9 from django.core.urlresolvers import reverse
10 from django import http
11 from django.http import Http404, HttpResponseForbidden
12 from django.middleware.gzip import GZipMiddleware
13 from django.utils.decorators import decorator_from_middleware
14 from django.utils.encoding import smart_unicode
15 from django.utils.formats import localize
16 from django.utils.translation import ugettext as _
17 from django.views.decorators.http import require_POST, require_GET
18 from django.shortcuts import get_object_or_404, render
20 from catalogue.models import Book, Chunk, Template
22 from wiki import forms
23 from wiki.helpers import JSONResponse, JSONFormInvalid, ajax_require_permission
24 from wiki.models import Theme
27 # Quick hack around caching problems, TODO: use ETags
29 from django.views.decorators.cache import never_cache
31 logger = logging.getLogger("fnp.wiki")
36 def get_history(chunk):
38 for change in chunk.history():
40 "version": change.revision,
41 "description": change.description,
42 "author": change.author_str(),
43 "date": localize(change.created_at),
44 "publishable": _("Publishable") + "\n" if change.publishable else "",
45 "tag": ',\n'.join(unicode(tag) for tag in change.tags.all()),
47 _("Published") + ": " +
48 localize(change.publish_log.order_by('-book_record__timestamp')[0].book_record.timestamp)
49 if change.publish_log.exists() else ""),
55 def editor(request, slug, chunk=None, template_name='wiki/bootstrap.html'):
57 chunk = Chunk.get(slug, chunk)
58 except Chunk.MultipleObjectsReturned:
60 except Chunk.DoesNotExist:
63 Book.objects.get(slug=slug)
64 except Book.DoesNotExist:
65 return http.HttpResponseRedirect(reverse("catalogue_create_missing", args=[slug]))
70 if not chunk.book.accessible(request):
71 return HttpResponseForbidden("Not authorized.")
73 access_time = datetime.now()
74 last_books = request.session.get("wiki_last_books", {})
75 last_books[slug, chunk.slug] = {
77 'title': chunk.pretty_name(),
80 if len(last_books) > MAX_LAST_DOCS:
81 oldest_key = min(last_books, key=lambda x: last_books[x]['time'])
82 del last_books[oldest_key]
83 request.session['wiki_last_books'] = last_books
85 save_form = forms.DocumentTextSaveForm(user=request.user, chunk=chunk, prefix="textsave")
87 version = int(request.GET.get('version', ''))
91 text = chunk.at_revision(version).materialize()
93 text = chunk.materialize()
94 gallery_dir = os.path.join(settings.MEDIA_ROOT, settings.IMAGE_DIR, chunk.book.gallery)
95 materials = set(os.listdir(gallery_dir)) if os.path.isdir(gallery_dir) else []
96 materials.update([n.rsplit('.', 1)[0] for n in materials])
97 return render(request, template_name, {
98 'serialized_document_data': json.dumps({
100 'document_id': chunk.id,
101 'title': chunk.book.title,
102 'history': get_history(chunk),
103 'version': version or chunk.revision(),
104 'stage': chunk.stage.name if chunk.stage else None,
105 'assignment': chunk.user.username if chunk.user else None
107 'serialized_templates': json.dumps([
108 {'id': t.id, 'name': t.name, 'content': t.content} for t in Template.objects.filter(is_partial=True)
111 "text_save": save_form,
112 "text_revert": forms.DocumentTextRevertForm(prefix="textrevert")
114 'tags': list(save_form.fields['stage_completed'].choices),
115 'can_pubmark': request.user.has_perm('catalogue.can_pubmark'),
116 'slug': chunk.book.slug,
117 'gallery': chunk.book.gallery,
118 'materials': json.dumps(list(materials)),
123 def editor_readonly(request, slug, chunk=None, template_name='wiki/document_details_readonly.html'):
125 chunk = Chunk.get(slug, chunk)
126 revision = request.GET['revision']
127 except (Chunk.MultipleObjectsReturned, Chunk.DoesNotExist, KeyError):
129 if not chunk.book.accessible(request):
130 return HttpResponseForbidden("Not authorized.")
132 access_time = datetime.now()
133 last_books = request.session.get("wiki_last_books", {})
134 last_books[slug, chunk.slug] = {
136 'title': chunk.book.title,
139 if len(last_books) > MAX_LAST_DOCS:
140 oldest_key = min(last_books, key=lambda x: last_books[x]['time'])
141 del last_books[oldest_key]
142 request.session['wiki_last_books'] = last_books
144 return render(request, template_name, {
146 'revision': revision,
148 'REDMINE_URL': settings.REDMINE_URL,
153 @decorator_from_middleware(GZipMiddleware)
154 def text(request, chunk_id):
155 doc = get_object_or_404(Chunk, pk=chunk_id)
156 if not doc.book.accessible(request):
157 return HttpResponseForbidden("Not authorized.")
159 if request.method == 'POST':
160 form = forms.DocumentTextSaveForm(request.POST, user=request.user, chunk=doc, prefix="textsave")
163 parent_revision = form.cleaned_data['parent_revision']
164 revision = doc.revision()
165 return JSONResponse({
166 'text': doc.materialize() if parent_revision != revision else None,
168 'stage': doc.stage.name if doc.stage else None,
169 'assignment': doc.user.username if doc.user else None
172 return JSONFormInvalid(form)
174 revision = request.GET.get("revision", None)
177 revision = int(revision)
178 except (ValueError, TypeError):
179 revision = doc.revision()
181 if revision is not None:
182 text = doc.at_revision(revision).materialize()
186 return JSONResponse({
189 'revision': revision,
195 def revert(request, chunk_id):
196 form = forms.DocumentTextRevertForm(request.POST, prefix="textrevert")
198 doc = get_object_or_404(Chunk, pk=chunk_id)
199 if not doc.book.accessible(request):
200 return HttpResponseForbidden("Not authorized.")
202 revision = form.cleaned_data['revision']
204 comment = form.cleaned_data['comment']
205 comment += "\n#revert to %s" % revision
207 if request.user.is_authenticated():
208 author = request.user
212 before = doc.revision()
213 logger.info("Reverting %s to %s", chunk_id, revision)
214 doc.at_revision(revision).revert(author=author, description=comment)
216 return JSONResponse({
217 'document': doc.materialize() if before != doc.revision() else None,
218 'version': doc.revision(),
221 return JSONFormInvalid(form)
225 def gallery(request, directory):
228 smart_unicode(settings.MEDIA_URL),
229 smart_unicode(settings.IMAGE_DIR),
230 smart_unicode(directory)))
232 base_dir = os.path.join(
233 smart_unicode(settings.MEDIA_ROOT),
234 smart_unicode(settings.IMAGE_DIR),
235 smart_unicode(directory))
237 def map_to_url(filename):
238 return urllib.quote("%s/%s" % (base_url, smart_unicode(filename)))
240 def is_image(filename):
241 return os.path.splitext(filename)[1].lower() in (u'.jpg', u'.jpeg', u'.png')
243 images = [map_to_url(f) for f in map(smart_unicode, os.listdir(base_dir)) if is_image(f)]
246 if not request.user.is_authenticated():
247 return HttpResponseForbidden("Not authorized.")
249 return JSONResponse(images)
250 except (IndexError, OSError):
251 logger.exception("Unable to fetch gallery")
256 def diff(request, chunk_id):
257 revA = int(request.GET.get('from', 0))
258 revB = int(request.GET.get('to', 0))
261 revA, revB = revB, revA
266 doc = get_object_or_404(Chunk, pk=chunk_id)
267 if not doc.book.accessible(request):
268 return HttpResponseForbidden("Not authorized.")
270 # allow diff from the beginning
272 docA = doc.at_revision(revA).materialize()
275 docB = doc.at_revision(revB).materialize()
277 return http.HttpResponse(nice_diff.html_diff_table(docA.splitlines(), docB.splitlines(), context=3))
281 def revision(request, chunk_id):
282 doc = get_object_or_404(Chunk, pk=chunk_id)
283 if not doc.book.accessible(request):
284 return HttpResponseForbidden("Not authorized.")
285 return http.HttpResponse(str(doc.revision()))
289 def history(request, chunk_id):
291 doc = get_object_or_404(Chunk, pk=chunk_id)
292 if not doc.book.accessible(request):
293 return HttpResponseForbidden("Not authorized.")
295 return JSONResponse(get_history(doc))
299 @ajax_require_permission('catalogue.can_pubmark')
300 def pubmark(request, chunk_id):
301 form = forms.DocumentPubmarkForm(request.POST, prefix="pubmark")
303 doc = get_object_or_404(Chunk, pk=chunk_id)
304 if not doc.book.accessible(request):
305 return HttpResponseForbidden("Not authorized.")
307 revision = form.cleaned_data['revision']
308 publishable = form.cleaned_data['publishable']
309 change = doc.at_revision(revision)
310 if publishable != change.publishable:
311 change.set_publishable(publishable)
312 return JSONResponse({"message": _("Revision marked")})
314 return JSONResponse({"message": _("Nothing changed")})
316 return JSONFormInvalid(form)
320 prefix = request.GET.get('q', '')
321 return http.HttpResponse('\n'.join([str(t) for t in Theme.objects.filter(name__istartswith=prefix)]))