c3fd6e38e148810ef4350a67b5f6e33e13e79c55
[redakcja.git] / apps / wiki / views.py
1 import os
2
3 from django.conf import settings
4 from django.views.generic.simple import direct_to_template
5 from django.http import HttpResponse, Http404
6 from django.utils import simplejson as json
7
8 from wiki.models import Document, DocumentNotFound, getstorage
9 from wiki.forms import DocumentForm
10 from datetime import datetime
11 from django.utils.encoding import smart_unicode
12 import wlapi
13
14 #
15 # Quick hack around caching problems, TODO: use ETags
16 #
17 from django.views.decorators.cache import never_cache
18
19 import logging
20 logger = logging.getLogger("fnp.peanut.api")
21
22 import nice_diff
23 import operator
24
25 MAX_LAST_DOCS = 10
26
27 class DateTimeEncoder(json.JSONEncoder):
28      def default(self, obj):
29          if isinstance(obj, datetime):
30              return datetime.ctime(obj) + " " + (datetime.tzname(obj) or 'GMT')
31          return json.JSONEncoder.default(self, obj)
32
33 @never_cache
34 def document_list(request, template_name = 'wiki/document_list.html'):
35     # TODO: find a way to cache "Storage All"
36     return direct_to_template(request, template_name, extra_context = {
37         'document_list': getstorage().all(),
38         'last_docs': sorted(request.session.get("wiki_last_docs", {}).items(), 
39                         key=operator.itemgetter(1), reverse = True)
40     })  
41
42 @never_cache
43 def document_detail(request, name, template_name = 'wiki/document_details.html'):
44     
45     try:
46         document = getstorage().get(name)
47     except DocumentNotFound:        
48         raise Http404
49     
50     access_time = datetime.now()
51     last_documents = request.session.get("wiki_last_docs", {})      
52     last_documents[name] = access_time
53     
54     if len(last_documents) > MAX_LAST_DOCS:
55         oldest_key = min(last_documents, key = last_documents.__getitem__)
56         del last_documents[oldest_key]        
57     request.session['wiki_last_docs'] = last_documents      
58
59     return direct_to_template(request, template_name, extra_context = {
60         'document': document,        
61     })
62
63 @never_cache
64 def document_text(request, name):
65     try:
66         document = getstorage().get(name)
67     except DocumentNotFound:        
68         raise Http404
69     
70     if request.method == 'POST':        
71         form = DocumentForm(request.POST, instance = document)
72         if form.is_valid():
73             document = form.save(document_author = request.user.username)
74             return HttpResponse(json.dumps({'text': document.plain_text, 'meta': document.meta(), 'revision': document.revision()}))
75         else:
76             return HttpResponse(json.dumps({'errors': form.errors}))
77     else:
78         return HttpResponse(json.dumps({'text': document.plain_text, 'meta': document.meta(), 'revision': document.revision()}))
79    
80
81
82 @never_cache
83 def document_gallery(request, directory):
84     try:
85         base_dir = os.path.join(
86                     smart_unicode(settings.MEDIA_ROOT), 
87                     smart_unicode(settings.FILEBROWSER_DIRECTORY),
88                     smart_unicode(directory) )
89         
90         def map_to_url(filename):           
91                          
92             return '%s%s%s/%s' % (
93                         smart_unicode(settings.MEDIA_URL),                         
94                         smart_unicode(settings.FILEBROWSER_DIRECTORY),
95                         smart_unicode(directory),
96                         smart_unicode(filename)
97             )
98             
99         def is_image(filename):
100             return os.path.splitext(f)[1].lower() in (u'.jpg', u'.jpeg', u'.png')
101             
102         images = [ map_to_url(f) for f in map(smart_unicode, os.listdir(base_dir)) if is_image(f) ]
103         images.sort()
104         return HttpResponse(json.dumps(images))
105     except (IndexError, OSError), exc:
106         import traceback
107         traceback.print_exc()
108
109         raise Http404
110     
111 @never_cache
112 def document_diff(request, name, revA, revB):
113     storage = getstorage()     
114     docA = storage.get(name, int(revA))
115     docB = storage.get(name, int(revB)) 
116     
117     
118     return HttpResponse(nice_diff.html_diff_table(docA.plain_text.splitlines(), 
119                                          docB.plain_text.splitlines()) )                                           
120     
121 @never_cache    
122 def document_history(request, name):
123     storage = getstorage()
124     
125     return HttpResponse( 
126                 json.dumps(storage.history(name), cls=DateTimeEncoder), 
127                 mimetype='application/json')
128     
129     
130 @never_cache
131 def document_publish(request, name, version):
132     storage = getstorage()
133     
134     # get the document
135     try:
136         document = storage.get(name, revision = int(version))
137     except DocumentNotFound:        
138         raise Http404
139     
140     api = wlapi.WLAPI(settings.WL_API_CONFIG)    
141     try:        
142         result = {"success": True, "result": api.publish_book(document)}
143     except wlapi.APICallException, e:                        
144         result = {"success": False, "reason": str(e)}
145         
146     return HttpResponse( json.dumps(result), mimetype='application/json')