|
27
|
1 |
import logging |
|
|
2 |
import json |
|
37
|
3 |
import simplejson |
|
27
|
4 |
from django.http import Http404 |
|
|
5 |
#from django.http import HttpResponseRedirect |
|
|
6 |
from django.contrib.auth import logout |
|
37
|
7 |
from django.shortcuts import render_to_response, redirect |
|
27
|
8 |
from django.template import RequestContext |
|
|
9 |
from django.contrib.auth import authenticate |
|
|
10 |
from django.contrib.auth import login |
|
|
11 |
from django.http import HttpResponseRedirect, HttpResponse |
|
|
12 |
from django.contrib.auth.decorators import login_required |
|
|
13 |
from controller.Searcher import Searcher |
|
|
14 |
from controller.ClusterAnnotation import ClusterAnnotation |
|
|
15 |
from controller.DocumentAnnotation import DocumentAnnotation |
|
|
16 |
from controller.DocumentaryFile import DocumentaryFile |
|
|
17 |
from controller.Documents import Documents |
|
|
18 |
from controller.DocumentaryFiles import DocumentaryFiles |
|
|
19 |
from controller.Clusters import Clusters |
|
|
20 |
from controller.DocumentaryFileAnnotation import DocumentaryFileAnnotation |
|
37
|
21 |
from dataparser.ClientSearchAttributes import ClientSearchAttributes |
|
27
|
22 |
from document.models import Documentaryfile |
|
37
|
23 |
from django.core.urlresolvers import reverse |
|
|
24 |
from mediapartdb.MediapartReader import MediapartReader |
|
27
|
25 |
|
|
|
26 |
logger = logging.getLogger('document') |
|
|
27 |
|
|
37
|
28 |
def article(request,cluster_title, id_article): |
|
|
29 |
logger.info('article called'+str(request)) |
|
|
30 |
logger.info('article called'+str(id_article)) |
|
|
31 |
reader = MediapartReader() |
|
|
32 |
url = reader.get_url(str(id_article)) |
|
|
33 |
logger.info('url'+str(url)) |
|
|
34 |
my_data_dictionary = {'url_article': url, 'cluster_title': cluster_title} |
|
|
35 |
|
|
|
36 |
my_data_dictionary['dossierDocs'] = [] |
|
|
37 |
|
|
|
38 |
|
|
|
39 |
dossierDoc = [] |
|
|
40 |
if request.user.is_authenticated(): |
|
|
41 |
logger.info('user') |
|
|
42 |
documentaryFiles = Documentaryfile.objects.filter(user=request.user.id) |
|
|
43 |
if documentaryFiles: |
|
|
44 |
logger.info('lengthdocumentaryFiles = '+str(len(documentaryFiles))) |
|
|
45 |
for docfile in documentaryFiles: |
|
|
46 |
dossierDoc.append({'title':docfile.title, 'description':docfile.description, 'url':docfile.image.url, 'id':str(docfile.id)}) |
|
|
47 |
logger.info('dossierDoc = '+str(dossierDoc)) |
|
|
48 |
my_data_dictionary['dossierDocs'].append(dossierDoc) |
|
|
49 |
return render_to_response('article.html', my_data_dictionary, context_instance=RequestContext(request)) |
|
|
50 |
|
|
27
|
51 |
|
|
|
52 |
def login_view(request): |
|
|
53 |
logger.info('login_view called!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!') |
|
37
|
54 |
logger.info('login_view session_items ********** ='+str(request.session.items())) |
|
27
|
55 |
username = request.POST['username'] |
|
37
|
56 |
logger.info('username = '+username) |
|
27
|
57 |
password = request.POST['password'] |
|
37
|
58 |
|
|
27
|
59 |
user = authenticate(username=username, password=password) |
|
37
|
60 |
request.session['user'] = username |
|
27
|
61 |
my_data_dictionary = {'loginstatus': ''} |
|
|
62 |
my_data_dictionary['dossierDocs'] = [] |
|
|
63 |
|
|
|
64 |
if user is not None: |
|
|
65 |
if user.is_active: |
|
|
66 |
login(request, user) |
|
|
67 |
dossierDoc = [] |
|
|
68 |
documentaryFiles = Documentaryfile.objects.filter(user=request.user.id) |
|
|
69 |
if documentaryFiles: |
|
|
70 |
for docfile in documentaryFiles: |
|
|
71 |
dossierDoc.append({'title':docfile.title, 'description':docfile.description, 'url':docfile.image.url}) |
|
|
72 |
|
|
|
73 |
my_data_dictionary['dossierDocs'].append(dossierDoc) |
|
|
74 |
request.session['dossierDocs'] = dossierDoc |
|
|
75 |
logger.info(my_data_dictionary['dossierDocs']) |
|
37
|
76 |
logger.info('user logged') |
|
27
|
77 |
else: |
|
|
78 |
logger.info('user not active') |
|
37
|
79 |
logger.onfo('user not active') |
|
27
|
80 |
my_data_dictionary['loginstatus'] = 'Utilisateur inactif' |
|
|
81 |
else: |
|
37
|
82 |
logger.info('invalid user') |
|
27
|
83 |
logger.info('invalid user') |
|
|
84 |
my_data_dictionary['loginstatus'] = 'Idenfiant ou mot de passe incorrect' |
|
|
85 |
|
|
|
86 |
request.session['refreshOnly'] = True |
|
|
87 |
return HttpResponseRedirect(request.GET.get('next', '/')) |
|
|
88 |
|
|
|
89 |
|
|
|
90 |
def logout_view(request): |
|
|
91 |
""" |
|
|
92 |
Logout users out and re-direct them to the main page. |
|
|
93 |
""" |
|
|
94 |
query_id = request.session['query_id'] |
|
|
95 |
key1 = request.session['key1'] |
|
37
|
96 |
jsonStreamgraph = request.session['jsonStreamgraph'] |
|
|
97 |
jsonTreemap = request.session['jsonTreemap'] |
|
|
98 |
|
|
27
|
99 |
logout(request) |
|
|
100 |
request.session['refreshOnly'] = True |
|
|
101 |
request.session['query_id'] = query_id |
|
|
102 |
request.session['key1'] = key1 |
|
37
|
103 |
request.session['jsonStreamgraph'] = jsonStreamgraph |
|
|
104 |
request.session['jsonTreemap'] = jsonTreemap |
|
|
105 |
logger.info('query_context4 ********** ='+str(request.session.items())) |
|
27
|
106 |
return HttpResponseRedirect(request.GET.get('next', '/')) |
|
|
107 |
|
|
37
|
108 |
def documentary_file_user_update(request): |
|
|
109 |
logger.info('documentary_file_user_update') |
|
|
110 |
myjson = {'user': request.user.username} |
|
|
111 |
myjson['dossierDocs'] = [] |
|
|
112 |
if request.user.is_authenticated(): |
|
|
113 |
logger.info('documentary_file_user_update is_authenticated') |
|
27
|
114 |
documentaryFiles = Documentaryfile.objects.filter(user=request.user.id) |
|
|
115 |
if documentaryFiles: |
|
|
116 |
for docfile in documentaryFiles: |
|
37
|
117 |
logger.info('docfile.title = '+str(docfile.title)) |
|
|
118 |
dossierDoc = {'title':docfile.title, 'description':docfile.description, 'url':docfile.image.url, 'id':docfile.id} |
|
|
119 |
myjson['dossierDocs'].append(dossierDoc) |
|
|
120 |
else: |
|
|
121 |
logger.info('documentary_file_user_update not is_authenticated') |
|
|
122 |
json = simplejson.dumps(myjson) |
|
|
123 |
return HttpResponse(json) |
|
|
124 |
|
|
|
125 |
|
|
|
126 |
def document_main_page(request,query=0,cluster=0,offset=0,count=0,docId=0): |
|
|
127 |
logger.info('document_main_page called'+str(request)) |
|
|
128 |
logger.info('document_main_page session_items1 ********** ='+str(request.session.items())) |
|
|
129 |
my_data_dictionary = {'user': request.user} |
|
|
130 |
my_data_dictionary['dossierDocs'] = [] |
|
|
131 |
my_data_dictionary['mydossierDoc'] = '' |
|
|
132 |
|
|
|
133 |
dossierDoc = [] |
|
|
134 |
if request.user.is_authenticated(): |
|
|
135 |
logger.info('user') |
|
|
136 |
documentaryFiles = Documentaryfile.objects.filter(user=request.user.id) |
|
|
137 |
if documentaryFiles: |
|
|
138 |
logger.info('lengthdocumentaryFiles = '+str(len(documentaryFiles))) |
|
|
139 |
for docfile in documentaryFiles: |
|
|
140 |
dossierDoc.append({'title':docfile.title, 'description':docfile.description, 'url':docfile.image.url, 'id':str(docfile.id)}) |
|
|
141 |
logger.info('dossierDoc = '+str(dossierDoc)) |
|
27
|
142 |
my_data_dictionary['dossierDocs'].append(dossierDoc) |
|
37
|
143 |
|
|
|
144 |
if request.is_ajax(): |
|
|
145 |
logger.info('is_ajax') |
|
|
146 |
requestType = request.POST['requestType'] |
|
|
147 |
|
|
|
148 |
if requestType == "streamgraph": |
|
|
149 |
logger.info('streamgraph') |
|
|
150 |
if request.session['refreshOnly'] == False: |
|
|
151 |
request.session['from_date'] = request.POST['from_date'] |
|
|
152 |
request.session['to_date'] = request.POST['to_date'] |
|
|
153 |
request.session['category']= request.POST.getlist('categories') |
|
|
154 |
searcher = Searcher(request); |
|
|
155 |
'''attr = ClientSearchAttributes(request) |
|
|
156 |
key1 = attr.get_hash_value_from_text_image() |
|
|
157 |
query_id = attr.get_hash_value() |
|
|
158 |
request.session['query_id'] = int(query_id) |
|
|
159 |
request.session['key1'] = int(key1)''' |
|
|
160 |
json = searcher.streamgraph() |
|
|
161 |
logger.info('document_main_page session_items2********** ='+str(request.session.items())) |
|
|
162 |
return HttpResponse(json) |
|
|
163 |
elif requestType == "treemap": |
|
|
164 |
logger.info('treemap') |
|
|
165 |
attr = ClientSearchAttributes(request) |
|
|
166 |
'''key1 = attr.get_hash_value_from_text_image() |
|
|
167 |
query_id = attr.get_hash_value() |
|
|
168 |
request.session['query_id'] = int(query_id) |
|
|
169 |
request.session['key1'] = int(key1)''' |
|
|
170 |
if request.session['refreshOnly'] == False: |
|
|
171 |
request.session['from_date'] = request.POST['from_date'] |
|
|
172 |
request.session['to_date'] = request.POST['to_date'] |
|
|
173 |
request.session['category']= request.POST.getlist('categories') |
|
27
|
174 |
|
|
37
|
175 |
searcher = Searcher(request); |
|
|
176 |
json = searcher.treemap() |
|
|
177 |
request.session['json'] = json |
|
|
178 |
logger.info('document_main_page session_items3 ********** ='+str(request.session.items())) |
|
|
179 |
return HttpResponse(json) |
|
|
180 |
elif requestType == "treemapUpdate": |
|
|
181 |
logger.info('treemapUpdate') |
|
|
182 |
return render_to_response('index.html', my_data_dictionary, context_instance=RequestContext(request)) |
|
|
183 |
elif requestType == "setAffichage": |
|
|
184 |
logger.info('setAffichage'+str(request.POST['typeTri'])) |
|
|
185 |
request.session['typeTri'] = request.POST['typeTri'] |
|
|
186 |
logger.info('jsontremap1*******'+str(request.session['jsonTreemap'])) |
|
|
187 |
myjsonTreemap = simplejson.loads(request.session['jsonTreemap']) |
|
|
188 |
logger.info('myjsonTreemap*******'+str(myjsonTreemap['query']['typeTri'])) |
|
|
189 |
myjsonTreemap['query']['typeTri'] = request.POST['typeTri'] |
|
|
190 |
request.session['jsonTreemap'] = simplejson.dumps(myjsonTreemap) |
|
|
191 |
logger.info('jsontremap2*******'+str(request.session['jsonTreemap'])) |
|
|
192 |
json = {'ok':'ok'} |
|
|
193 |
return HttpResponse(json) |
|
|
194 |
'''elif requestType == "documents": |
|
|
195 |
logger.info('documents'+str(query)) |
|
|
196 |
logger.info('documents'+str(cluster)) |
|
|
197 |
logger.info('documents'+str(offset)) |
|
|
198 |
logger.info('documents'+str(count)) |
|
|
199 |
documents = Documents(request) |
|
|
200 |
jsondocuments = documents.get_documents(query,cluster,offset,count) |
|
|
201 |
request.session['jsondocuments'] = jsondocuments |
|
|
202 |
return render_to_response('cluster.html',my_data_dictionary, context_instance=RequestContext(request))''' |
|
|
203 |
#return HttpResponse(jsondocuments) |
|
|
204 |
else: |
|
|
205 |
logger.info('is_not_ajax') |
|
|
206 |
if query != 0 or docId != 0: |
|
|
207 |
documents = Documents(request) |
|
|
208 |
jsondocuments = documents.get_documents(query,cluster,offset,count,docId) |
|
|
209 |
request.session['jsondocuments'] = jsondocuments |
|
|
210 |
return render_to_response('cluster.html',my_data_dictionary, context_instance=RequestContext(request)) |
|
|
211 |
else: |
|
|
212 |
try: |
|
|
213 |
filtre = request.POST['filtre'] |
|
|
214 |
if filtre == "nok": |
|
|
215 |
logger.info('filtre * == '+filtre) |
|
|
216 |
#if requestType == "streamgraph": |
|
|
217 |
searcher = Searcher(request) |
|
|
218 |
attr = ClientSearchAttributes(request) |
|
|
219 |
key1 = attr.get_hash_value_from_text_image() |
|
|
220 |
query_id = attr.get_hash_value() |
|
|
221 |
request.session['query_id'] = int(query_id) |
|
|
222 |
request.session['key1'] = int(key1) |
|
|
223 |
jsonstream = searcher.streamgraph() |
|
|
224 |
|
|
|
225 |
#return HttpResponse(json) |
|
|
226 |
#elif requestType == "treemap": |
|
|
227 |
#logger.info('treemap') |
|
|
228 |
#if request.session['refreshOnly'] == False and id==0: |
|
|
229 |
if request.session['refreshOnly'] == False: |
|
|
230 |
request.session['from_date'] = request.POST['from_date'] |
|
|
231 |
request.session['to_date'] = request.POST['to_date'] |
|
|
232 |
request.session['category']= request.POST.getlist('categories') |
|
|
233 |
|
|
|
234 |
searcher = Searcher(request) |
|
|
235 |
jsontreemap = searcher.treemap() |
|
|
236 |
#request.session['json'] = json |
|
|
237 |
logger.info('refreshnok ********** ='+str(request.session.items())) |
|
|
238 |
elif filtre == "ok": |
|
|
239 |
logger.info('filtre ! == '+filtre) |
|
|
240 |
searcher = Searcher(request) |
|
|
241 |
jsonstream = searcher.streamgraph() |
|
|
242 |
jsontreemap = searcher.treemap() |
|
|
243 |
except Exception, err: |
|
|
244 |
logger.info('exception') |
|
|
245 |
try: |
|
|
246 |
if request.session['refreshOnly'] == True: |
|
|
247 |
logger.info('refreshOnly TRUE') |
|
|
248 |
request.session['refreshOnly'] = False |
|
|
249 |
return render_to_response('index.html', my_data_dictionary, context_instance=RequestContext(request)) |
|
|
250 |
except Exception, err: |
|
|
251 |
request.session['refreshOnly'] = False |
|
|
252 |
request.session['jsonStreamgraph'] = {} |
|
|
253 |
request.session['jsonTreemap'] = {} |
|
|
254 |
request.session['json2'] = {} |
|
|
255 |
request.session['json'] = {} |
|
|
256 |
request.session['query_id_treemap'] = '' |
|
|
257 |
request.session['query_id_streamgraph'] = '' |
|
|
258 |
request.session['query_id'] = '' |
|
|
259 |
request.session['key1'] = '' |
|
|
260 |
request.session['from_date'] = '' |
|
|
261 |
request.session['to_date'] = '' |
|
|
262 |
request.session['category'] = [] |
|
|
263 |
request.session['typeTri'] = 'treemap' |
|
|
264 |
request.session['jsontreemapdossierdoc'] = '' |
|
|
265 |
request.session['jsonstreamgraphdossierdoc'] = '' |
|
|
266 |
logger.info('session id==0 ********** ='+str(request.session.items())) |
|
|
267 |
return render_to_response('index.html', my_data_dictionary, context_instance=RequestContext(request)) |
|
|
268 |
'''else: |
|
|
269 |
logger.info("id !=0") |
|
|
270 |
documentaryFile = Documentaryfile.objects.get(id=id) |
|
|
271 |
request.session['jsontreemap'] = documentaryFile.jsontreemap |
|
|
272 |
request.session['jsonstreamgraph'] = documentaryFile.jsonstreamgraph |
|
|
273 |
my_data_dictionary['mydossierDoc'] = {'dossierDocTitle':documentaryFile.title} |
|
|
274 |
logger.info('my_data_dictionary = '+str(my_data_dictionary)) |
|
|
275 |
return render_to_response('index-dossier.html',my_data_dictionary, context_instance=RequestContext(request))''' |
|
27
|
276 |
|
|
|
277 |
def get_mesdossiersDoc(request): |
|
|
278 |
logger.info('get_mesdossiersDoc called') |
|
|
279 |
my_data_dictionary = {'user': request.user} |
|
|
280 |
my_data_dictionary['loginstatus'] = '' |
|
|
281 |
my_data_dictionary['myDocumentaryFiles'] = '' |
|
|
282 |
logger.info('get_mesdossiersDoc called2') |
|
|
283 |
if not request.user.is_authenticated(): |
|
|
284 |
logger.info('Anonymous user') |
|
|
285 |
return render_to_response('index.html', my_data_dictionary, context_instance=RequestContext(request)) |
|
|
286 |
else: |
|
|
287 |
logger.info('user'+str(request.user)) |
|
|
288 |
documentaryFiles = Documentaryfile.objects.filter(user=request.user.id) |
|
|
289 |
if documentaryFiles: |
|
|
290 |
my_data_dictionary['myDocumentaryFiles'] = '<section id="dossierDoc"><h1>Mes dossiers docs</h1>' |
|
|
291 |
for docfile in documentaryFiles: |
|
37
|
292 |
logger.info('docfile.image.url = '+docfile.image.url) |
|
27
|
293 |
my_data_dictionary['myDocumentaryFiles'] += '<article style="width:278px">' |
|
37
|
294 |
#my_data_dictionary['myDocumentaryFiles'] += '<img src="{{ STATIC_URL }}images/' |
|
|
295 |
my_data_dictionary['myDocumentaryFiles'] += '<img src="' |
|
27
|
296 |
my_data_dictionary['myDocumentaryFiles'] += docfile.image.url |
|
37
|
297 |
my_data_dictionary['myDocumentaryFiles'] += '" style="height:29px;width:50px;float:left;padding-right:10px"/> <h2 style="float:left">' |
|
27
|
298 |
my_data_dictionary['myDocumentaryFiles'] += docfile.title |
|
|
299 |
my_data_dictionary['myDocumentaryFiles'] += '</h2><br><p>' |
|
|
300 |
my_data_dictionary['myDocumentaryFiles'] += docfile.description |
|
|
301 |
my_data_dictionary['myDocumentaryFiles'] += '</p></article>' |
|
|
302 |
|
|
|
303 |
# get user information here (documentary file ...) |
|
|
304 |
|
|
|
305 |
# |
|
|
306 |
return render_to_response('mesdossiersDoc.html', my_data_dictionary, context_instance=RequestContext(request)) |
|
|
307 |
|
|
|
308 |
|
|
37
|
309 |
'''def streamgraph(request): |
|
27
|
310 |
print 'streamgraph' |
|
|
311 |
if request.method == 'POST': |
|
|
312 |
print 'POST' |
|
|
313 |
searcher = Searcher(request); |
|
|
314 |
json = searcher.streamgraph() |
|
|
315 |
return HttpResponse(json) |
|
|
316 |
else: |
|
|
317 |
print 'ERROR' |
|
|
318 |
raise Http404 |
|
37
|
319 |
return HttpResponse("OK")''' |
|
27
|
320 |
|
|
37
|
321 |
def streamgraph(request): |
|
|
322 |
logger.info('streamgraph !!!! ') |
|
|
323 |
my_data_dictionary = {'user': request.user} |
|
|
324 |
searcher = Searcher(request); |
|
|
325 |
jsonStreamgraph = searcher.streamgraph() |
|
|
326 |
logger.info('jsonStreamgraph ====='+jsonStreamgraph) |
|
|
327 |
request.session['jsonStreamgraph'] = jsonStreamgraph |
|
|
328 |
'''return HttpResponse(json)''' |
|
|
329 |
|
|
|
330 |
|
|
|
331 |
if request.is_ajax(): |
|
|
332 |
print("is_ajax") |
|
|
333 |
return HttpResponse(json) |
|
|
334 |
else: |
|
|
335 |
print("isnot_ajax") |
|
|
336 |
return render_to_response('recherche.html',my_data_dictionary, context_instance=RequestContext(request)) |
|
27
|
337 |
|
|
|
338 |
def treemap(request): |
|
37
|
339 |
logger.info( 'TREEMAP ENTER !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!') |
|
|
340 |
logger.info('query_context1 ********** ='+str(request.session.items())) |
|
|
341 |
if request.session['refreshOnly'] == False: |
|
|
342 |
logger.info( 'TREEMAP ENTER refreshOnly FALSE!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!') |
|
|
343 |
request.session['from_date'] = request.POST['from_date'] |
|
|
344 |
request.session['to_date'] = request.POST['to_date'] |
|
|
345 |
request.session['category']= request.POST.getlist('categories') |
|
|
346 |
|
|
27
|
347 |
my_data_dictionary = {'user': request.user} |
|
|
348 |
my_data_dictionary['dossierDocs'] = [] |
|
|
349 |
dossierDoc = [] |
|
|
350 |
if request.user.is_authenticated(): |
|
|
351 |
print request.user.is_authenticated() |
|
|
352 |
documentaryFiles = Documentaryfile.objects.filter(user=request.user.id) |
|
|
353 |
if documentaryFiles: |
|
|
354 |
for docfile in documentaryFiles: |
|
|
355 |
dossierDoc.append({'title':docfile.title, 'description':docfile.description, 'url':docfile.image.url}) |
|
|
356 |
print dossierDoc |
|
|
357 |
my_data_dictionary['dossierDocs'].append(dossierDoc) |
|
|
358 |
logger.info(my_data_dictionary['dossierDocs']) |
|
37
|
359 |
|
|
27
|
360 |
searcher = Searcher(request); |
|
|
361 |
json = searcher.treemap() |
|
|
362 |
request.session['json'] = json |
|
|
363 |
if request.is_ajax(): |
|
|
364 |
print("is_ajax") |
|
|
365 |
return HttpResponse(json) |
|
|
366 |
else: |
|
|
367 |
print("isnot_ajax") |
|
37
|
368 |
return render_to_response('recherche.html',my_data_dictionary, context_instance=RequestContext(request)) |
|
27
|
369 |
|
|
|
370 |
|
|
37
|
371 |
def get_documents_with_annotations(request,query=0,cluster=0,offset=0,count=0,docId=0): |
|
|
372 |
logger.info('get_documents_with_annotations !!!!!!!!'+str(request)) |
|
|
373 |
|
|
27
|
374 |
'''if request.method == 'GET':''' |
|
|
375 |
if request.method == 'GET' and request.session['refreshOnly'] == True: |
|
37
|
376 |
logger.info("get_request and refresh") |
|
27
|
377 |
json2 = request.session['json2'] |
|
|
378 |
request.session['refreshOnly'] = False |
|
|
379 |
else: |
|
37
|
380 |
logger.info("NOT get_request and refresh") |
|
27
|
381 |
documents = Documents(request) |
|
|
382 |
json2 = documents.get_documents(query,cluster,offset,count) |
|
|
383 |
request.session['json2'] = json2 |
|
|
384 |
|
|
|
385 |
d = json.loads(json2) |
|
|
386 |
my_data_dictionary = {'cluster_title': d['cluster_title']} |
|
|
387 |
my_data_dictionary['dossierDocs'] = [] |
|
|
388 |
dossierDoc = [] |
|
|
389 |
|
|
|
390 |
if request.user.is_authenticated(): |
|
|
391 |
print request.user.is_authenticated() |
|
|
392 |
documentaryFiles = Documentaryfile.objects.filter(user=request.user.id) |
|
|
393 |
if documentaryFiles: |
|
|
394 |
for docfile in documentaryFiles: |
|
|
395 |
dossierDoc.append({'title':docfile.title, 'description':docfile.description, 'url':docfile.image.url}) |
|
|
396 |
print dossierDoc |
|
|
397 |
my_data_dictionary['dossierDocs'].append(dossierDoc) |
|
|
398 |
logger.info(my_data_dictionary['dossierDocs']) |
|
|
399 |
if request.is_ajax(): |
|
37
|
400 |
logger.info("is_ajax") |
|
27
|
401 |
return HttpResponse(json2) |
|
|
402 |
else: |
|
37
|
403 |
logger.info("is_not_ajax") |
|
27
|
404 |
return render_to_response('cluster.html',my_data_dictionary, context_instance=RequestContext(request)) |
|
|
405 |
'''return HttpResponse(json)''' |
|
|
406 |
|
|
|
407 |
'''else: |
|
|
408 |
raise Http404''' |
|
|
409 |
|
|
|
410 |
def get_annotations(request): |
|
|
411 |
if request.method == 'GET': |
|
|
412 |
print 'get_annotations' |
|
|
413 |
annotations = DocumentAnnotation(request); |
|
|
414 |
json = annotations.get_annotations() |
|
|
415 |
return HttpResponse(json) |
|
|
416 |
else: |
|
|
417 |
raise Http404 |
|
|
418 |
|
|
37
|
419 |
|
|
|
420 |
def get_documentary_file(request,myuser="", cluster=0,offset=0,count=0, docId=0): |
|
|
421 |
logger.info('get_documentary_file docId'+str(docId)) |
|
|
422 |
logger.info('get_documentary_file cluster'+str(cluster)) |
|
|
423 |
|
|
|
424 |
my_data_dictionary = {'user': request.user} |
|
|
425 |
my_data_dictionary['dossierDocs'] = [] |
|
|
426 |
|
|
|
427 |
|
|
|
428 |
dossierDoc = [] |
|
|
429 |
if request.user.is_authenticated(): |
|
|
430 |
logger.info('user') |
|
|
431 |
documentaryFiles = Documentaryfile.objects.filter(user=request.user.id) |
|
|
432 |
if documentaryFiles: |
|
|
433 |
logger.info('lengthdocumentaryFiles = '+str(len(documentaryFiles))) |
|
|
434 |
for docfile in documentaryFiles: |
|
|
435 |
dossierDoc.append({'title':docfile.title, 'description':docfile.description, 'url':docfile.image.url, 'id':str(docfile.id)}) |
|
|
436 |
logger.info('dossierDoc = '+str(dossierDoc)) |
|
|
437 |
my_data_dictionary['dossierDocs'].append(dossierDoc) |
|
|
438 |
|
|
|
439 |
documentaryFile = Documentaryfile.objects.get(id=docId) |
|
|
440 |
request.session['jsontreemapdossierdoc'] = documentaryFile.jsontreemap |
|
|
441 |
request.session['jsonstreamgraphdossierdoc'] = documentaryFile.jsonstreamgraph |
|
|
442 |
my_data_dictionary['mydossierDoc'] = {'dossierDocTitle':documentaryFile.title} |
|
27
|
443 |
|
|
37
|
444 |
if int(count) != 0: |
|
|
445 |
logger.info('get_documentary_file docId != 0') |
|
|
446 |
documents = Documents(request) |
|
|
447 |
jsondocuments = documents.get_documents(0,cluster,offset,count,docId) |
|
|
448 |
request.session['jsondocuments'] = jsondocuments |
|
|
449 |
return render_to_response('clusterDoc.html',my_data_dictionary, context_instance=RequestContext(request)) |
|
|
450 |
else: |
|
|
451 |
logger.info('my_data_dictionary = '+str(request.session['jsontreemapdossierdoc'])) |
|
|
452 |
logger.info('my_data_dictionary = '+str(request.session['jsonstreamgraphdossierdoc'])) |
|
|
453 |
return render_to_response('index-dossier.html',my_data_dictionary, context_instance=RequestContext(request)) |
|
27
|
454 |
|
|
37
|
455 |
|
|
|
456 |
'''if request.user.is_authenticated(): |
|
|
457 |
logger.info(request.user.is_authenticated()) |
|
|
458 |
documentaryFiles = Documentaryfile.objects.filter(user=request.user.id) |
|
|
459 |
if documentaryFiles: |
|
|
460 |
for docfile in documentaryFiles: |
|
|
461 |
dossierDoc.append({'title':docfile.title, 'description':docfile.description, 'url':docfile.image.url, 'id':docfile.id}) |
|
|
462 |
logger.info('dossierDoc = '+str(dossierDoc)) |
|
|
463 |
my_data_dictionary['dossierDocs'].append(dossierDoc) |
|
|
464 |
logger.info(my_data_dictionary['dossierDocs']) |
|
|
465 |
return render_to_response('index-dossier.html',my_data_dictionary, context_instance=RequestContext(request))''' |
|
|
466 |
|
|
|
467 |
#@login_required |
|
|
468 |
def documentary_files(request,myuser=""): |
|
|
469 |
logger.info('documentary_files'+str(request.user)) |
|
|
470 |
doc_files = DocumentaryFiles(request); |
|
|
471 |
json = doc_files.get_files(myuser,'0','12') |
|
|
472 |
request.session['json3'] = json |
|
|
473 |
|
|
|
474 |
my_data_dictionary = {} |
|
|
475 |
my_data_dictionary['dossierDocs'] = [] |
|
|
476 |
dossierDoc = [] |
|
|
477 |
|
|
|
478 |
if request.user.is_authenticated(): |
|
|
479 |
logger.info(request.user.is_authenticated()) |
|
|
480 |
documentaryFiles = Documentaryfile.objects.filter(user=request.user.id) |
|
|
481 |
if documentaryFiles: |
|
|
482 |
for docfile in documentaryFiles: |
|
|
483 |
dossierDoc.append({'title':docfile.title, 'description':docfile.description, 'url':docfile.image.url, 'id':docfile.id}) |
|
|
484 |
logger.info('dossierDoc = '+str(dossierDoc)) |
|
|
485 |
my_data_dictionary['dossierDocs'].append(dossierDoc) |
|
|
486 |
logger.info(my_data_dictionary['dossierDocs']) |
|
|
487 |
|
|
|
488 |
return render_to_response('dossiersdocumentaire.html',my_data_dictionary, context_instance=RequestContext(request)) |
|
|
489 |
|
|
27
|
490 |
|
|
|
491 |
def documentary_file_visibility(request): |
|
|
492 |
if request.method == 'POST': |
|
|
493 |
print 'documentary_file_visibility' |
|
|
494 |
documentary_file = DocumentaryFile(request); |
|
|
495 |
json = documentary_file.visibilityChange() |
|
|
496 |
return HttpResponse(json) |
|
|
497 |
else: |
|
|
498 |
raise Http404 |
|
|
499 |
return HttpResponse("OK") |
|
|
500 |
|
|
37
|
501 |
def documentary_file_delete(request,docId=0): |
|
|
502 |
logger.info('isajax ???'+str(request.is_ajax())) |
|
27
|
503 |
if request.method == 'POST': |
|
37
|
504 |
logger.info('documentary_file_delete = '+str(docId)) |
|
27
|
505 |
documentaryfile_var = DocumentaryFile(request); |
|
37
|
506 |
json = documentaryfile_var.delete(docId) |
|
|
507 |
logger.info('NEXT ====='+str(request.GET.get('next', '/'))) |
|
|
508 |
return HttpResponseRedirect(request.GET.get('next', '/')) |
|
|
509 |
#return HttpResponse(json) |
|
27
|
510 |
else: |
|
|
511 |
raise Http404 |
|
37
|
512 |
#return HttpResponse("OK") |
|
27
|
513 |
|
|
|
514 |
def documentary_file_create(request): |
|
37
|
515 |
logger.info('documentary_file_create = '+str(request)) |
|
|
516 |
logger.info('documentary_file_create session_items ********** ='+str(request.session.items())) |
|
|
517 |
if not request.user.is_authenticated(): |
|
|
518 |
logger.info('Anonymous user') |
|
|
519 |
myjson = {'user':'Vous devez vous connecter.'} |
|
|
520 |
json = simplejson.dumps(myjson) |
|
27
|
521 |
else: |
|
37
|
522 |
if request.method == 'POST': |
|
|
523 |
logger.info('documentary_file create') |
|
|
524 |
documentary_file = DocumentaryFile(request); |
|
|
525 |
json = documentary_file.create() |
|
|
526 |
else: |
|
|
527 |
raise Http404 |
|
|
528 |
return HttpResponse("OK") |
|
|
529 |
return HttpResponse(json) |
|
27
|
530 |
|
|
|
531 |
def cluster_annotation_create(request): |
|
|
532 |
if request.method == 'POST': |
|
|
533 |
logger.info('cluster annotation create') |
|
|
534 |
clusterAnnotation_var = ClusterAnnotation(request); |
|
|
535 |
json = clusterAnnotation_var.create() |
|
|
536 |
|
|
|
537 |
return HttpResponse(json) |
|
|
538 |
else: |
|
|
539 |
raise Http404 |
|
|
540 |
return HttpResponse("OK") |
|
|
541 |
|
|
|
542 |
def cluster_annotation_delete(request): |
|
|
543 |
if request.method == 'POST': |
|
|
544 |
logger.info('cluster annotation delete') |
|
|
545 |
clusterAnnotation_var = ClusterAnnotation(request); |
|
|
546 |
json = clusterAnnotation_var.delete() |
|
|
547 |
|
|
|
548 |
return HttpResponse(json) |
|
|
549 |
else: |
|
|
550 |
raise Http404 |
|
|
551 |
return HttpResponse("OK") |
|
|
552 |
|
|
|
553 |
def document_annotation_create(request): |
|
|
554 |
if request.method == 'POST': |
|
|
555 |
logger.info('document annotation create') |
|
|
556 |
document_annotation = DocumentAnnotation(request); |
|
|
557 |
json = document_annotation.create() |
|
|
558 |
|
|
|
559 |
return HttpResponse(json) |
|
|
560 |
else: |
|
|
561 |
raise Http404 |
|
|
562 |
return HttpResponse("OK") |
|
|
563 |
|
|
|
564 |
def document_annotation_delete(request): |
|
|
565 |
if request.method == 'POST': |
|
|
566 |
logger.info('document annotation delete') |
|
|
567 |
document_annotation = DocumentAnnotation(request); |
|
|
568 |
json = document_annotation.delete() |
|
|
569 |
|
|
|
570 |
return HttpResponse(json) |
|
|
571 |
else: |
|
|
572 |
raise Http404 |
|
|
573 |
return HttpResponse("OK") |
|
|
574 |
|
|
|
575 |
def get_clusters(request): |
|
|
576 |
if request.method == 'GET': |
|
|
577 |
logger.info('get clusters of a documentary file') |
|
|
578 |
clusters = Clusters(request); |
|
|
579 |
json = clusters.get_treemap_of_clusters() |
|
|
580 |
|
|
|
581 |
return HttpResponse(json) |
|
|
582 |
else: |
|
|
583 |
raise Http404 |
|
|
584 |
|
|
|
585 |
def create_annotation_on_documentary_file(request): |
|
|
586 |
if request.method == 'POST': |
|
|
587 |
logger.info('create an annotation on a documentary file') |
|
|
588 |
annotation = DocumentaryFileAnnotation(request); |
|
|
589 |
json = annotation.create() |
|
|
590 |
|
|
|
591 |
return HttpResponse(json) |
|
|
592 |
else: |
|
|
593 |
raise Http404 |
|
|
594 |
|
|
|
595 |
def delete_annotation_on_documentary_file(request): |
|
|
596 |
if request.method == 'POST': |
|
|
597 |
logger.info('delete an annotation on a documentary file') |
|
|
598 |
annotation = DocumentaryFileAnnotation(request); |
|
|
599 |
json = annotation.delete() |
|
|
600 |
|
|
|
601 |
return HttpResponse(json) |
|
|
602 |
else: |
|
|
603 |
raise Http404 |