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