5bf3ce4d68342f6e90cbfbf0bb952264d08efd47
[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, DocumentTextSaveForm
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         'document_info': document.info,
62         'document_meta': document.meta,
63         'text_save_form': DocumentTextSaveForm(),         
64     })
65
66 @never_cache
67 def document_text(request, name):
68     try:
69         document = getstorage().get(name)
70     except DocumentNotFound:        
71         raise Http404
72     
73     if request.method == 'POST':        
74         form = DocumentForm(request.POST, instance = document)
75         if form.is_valid():
76             document = form.save(document_author = request.user.username)
77             return HttpResponse(json.dumps({'text': document.plain_text, 'meta': document.meta(), 'revision': document.revision()}))
78         else:
79             return HttpResponse(json.dumps({'errors': list(form.errors)}))
80     else:
81         return HttpResponse(json.dumps({'text': document.plain_text, 'meta': document.meta(), 'revision': document.revision()}))
82    
83
84
85 @never_cache
86 def document_gallery(request, directory):
87     try:
88         base_dir = os.path.join(
89                     smart_unicode(settings.MEDIA_ROOT), 
90                     smart_unicode(settings.FILEBROWSER_DIRECTORY),
91                     smart_unicode(directory) )
92         
93         def map_to_url(filename):           
94                          
95             return '%s%s%s/%s' % (
96                         smart_unicode(settings.MEDIA_URL),                         
97                         smart_unicode(settings.FILEBROWSER_DIRECTORY),
98                         smart_unicode(directory),
99                         smart_unicode(filename)
100             )
101             
102         def is_image(filename):
103             return os.path.splitext(f)[1].lower() in (u'.jpg', u'.jpeg', u'.png')
104             
105         images = [ map_to_url(f) for f in map(smart_unicode, os.listdir(base_dir)) if is_image(f) ]
106         images.sort()
107         return HttpResponse(json.dumps(images))
108     except (IndexError, OSError), exc:
109         import traceback
110         traceback.print_exc()
111
112         raise Http404
113     
114 @never_cache
115 def document_diff(request, name, revA, revB):
116     storage = getstorage()     
117     docA = storage.get(name, int(revA))
118     docB = storage.get(name, int(revB)) 
119     
120     
121     return HttpResponse(nice_diff.html_diff_table(docA.plain_text.splitlines(), 
122                                          docB.plain_text.splitlines()) )                                           
123     
124 @never_cache    
125 def document_history(request, name):
126     storage = getstorage()
127     
128     return HttpResponse( 
129                 json.dumps(storage.history(name), cls=DateTimeEncoder), 
130                 mimetype='application/json')
131     
132     
133 @never_cache
134 def document_publish(request, name, version):
135     storage = getstorage()
136     
137     # get the document
138     try:
139         document = storage.get(name, revision = int(version))
140     except DocumentNotFound:        
141         raise Http404
142     
143     api = wlapi.WLAPI(settings.WL_API_CONFIG)    
144     try:        
145         result = {"success": True, "result": api.publish_book(document)}
146     except wlapi.APICallException, e:                        
147         result = {"success": False, "reason": str(e)}
148         
149     return HttpResponse( json.dumps(result), mimetype='application/json')