|
1 import django.core.urlresolvers |
|
2 from django.http import HttpResponse, HttpResponseRedirect |
|
3 from django.shortcuts import render_to_response, get_object_or_404 |
|
4 from django.template import RequestContext |
|
5 from django.core.urlresolvers import reverse |
|
6 from django.contrib.auth.decorators import login_required |
|
7 from django.conf import settings |
|
8 from fileimport import * |
|
9 from forms import LdtImportForm, LdtAddForm, SearchForm, AddProjectForm, CopyProjectForm |
|
10 from ldt.core.models import Owner |
|
11 from models import * |
|
12 from utils import * |
|
13 from contentindexer import * |
|
14 from string import Template |
|
15 from Ft.Xml import MarkupWriter |
|
16 import cgi |
|
17 import uuid |
|
18 import base64 |
|
19 import lucene |
|
20 import xml.dom |
|
21 import xml.dom.ext |
|
22 import xml.dom.minidom |
|
23 |
|
24 |
|
25 |
|
26 def searchForm(request): |
|
27 form = SearchForm() |
|
28 return render_to_response('ldt/ldt/search_form.html',{'form': form} , context_instance=RequestContext(request)) |
|
29 |
|
30 def searchIndex(request): |
|
31 |
|
32 sform = SearchForm(request.POST) |
|
33 if sform.is_valid(): |
|
34 search = sform.cleaned_data["search"] |
|
35 |
|
36 |
|
37 queryStr = base64.urlsafe_b64encode(search.encode('utf8')) |
|
38 field = request.POST["field"] |
|
39 language_code = request.LANGUAGE_CODE[:2] |
|
40 |
|
41 url = settings.WEB_URL + django.core.urlresolvers.reverse("ldt.ldt_utils.views.searchInit", args=[field, queryStr]) |
|
42 return render_to_response('ldt/ldt/init_ldt.html', {'MEDIA_URL': settings.MEDIA_URL, 'colorurl': settings.MEDIA_URL+'swf/ldt/pkg/color.xml', 'i18nurl': settings.MEDIA_URL+'swf/ldt/pkg/i18n', 'language': language_code, 'baseurl': settings.MEDIA_URL+'swf/ldt/', 'url': url}, context_instance=RequestContext(request)) |
|
43 else: |
|
44 resp = HttpResponse() |
|
45 resp.write("<html><head></head><body>Error : No result</body></html>"); |
|
46 |
|
47 def searchIndexGet(request, field, query): |
|
48 |
|
49 language_code = request.LANGUAGE_CODE[:2] |
|
50 url = settings.WEB_URL + django.core.urlresolvers.reverse("ldt.ldt_utils.views.searchInit", args=[field, query]) |
|
51 return render_to_response('irisuser/ldt/init_ldt.html', {'MEDIA_URL': settings.MEDIA_URL, 'colorurl': settings.MEDIA_URL+'swf/ldt/pkg/color.xml', 'i18nurl': settings.MEDIA_URL+'swf/ldt/pkg/i18n', 'language': language_code, 'baseurl': settings.MEDIA_URL+'swf/ldt/', 'url': url}, context_instance=RequestContext(request)) |
|
52 |
|
53 def searchInit(request, field, query): |
|
54 |
|
55 ldtgen = LdtUtils() |
|
56 |
|
57 doc = ldtgen.generateInit([field,query], 'ldt.ldt_utils.views.searchLdt', 'ldt.ldt_utils.views.searchSegments') |
|
58 |
|
59 resp = HttpResponse(mimetype="text/xml;charset=utf-8") |
|
60 xml.dom.ext.PrettyPrint(doc, resp) |
|
61 return resp |
|
62 |
|
63 def searchLdt(request, field, query, edition=None): |
|
64 |
|
65 contentList = [] |
|
66 resp = HttpResponse(mimetype="text/xml") |
|
67 queryStr = "" |
|
68 |
|
69 if query and len(query)>0: |
|
70 queryStr = base64.urlsafe_b64decode(query.encode("ascii")).decode("utf8") |
|
71 searcher = LdtSearch() |
|
72 ids = {} |
|
73 |
|
74 for result in searcher.query(field, queryStr): |
|
75 ids[result["iri_id"]] = "" |
|
76 |
|
77 id_list = ids.keys() |
|
78 |
|
79 if edition is not None: |
|
80 ids_editions = map(lambda t:t[0], filter(lambda id: id[0] is not None, Speak.objects.filter(session__day__edition=edition).order_by("session__start_ts", "order").values_list("content__iri_id"))) |
|
81 id_list = filter(lambda id: id in id_list, ids_editions) |
|
82 |
|
83 contentList = Content.objects.filter(iri_id__in=id_list) |
|
84 |
|
85 |
|
86 ldtgen = LdtUtils() |
|
87 ldtgen.generateLdt(contentList, file=resp, title = u"Recherche : " + queryStr) |
|
88 |
|
89 return resp |
|
90 |
|
91 |
|
92 def searchSegments(request, field, query, edition=None): |
|
93 |
|
94 if query and len(query)>0: |
|
95 searcher = LdtSearch() |
|
96 |
|
97 queryStr = base64.urlsafe_b64decode(query.encode("ascii")).decode("utf8") |
|
98 res = searcher.query(field, queryStr) |
|
99 else: |
|
100 res = [] |
|
101 |
|
102 iri_ids = None |
|
103 |
|
104 if edition is not None: |
|
105 iri_ids = map(lambda t:t[0], filter(lambda id: id[0] is not None, Speak.objects.filter(session__day__edition=edition).order_by("session__start_ts", "order").values_list("content__iri_id"))) |
|
106 |
|
107 doc = xml.dom.getDOMImplementation().createDocument(None, "iri", None) |
|
108 |
|
109 for resultMap in res: |
|
110 if iri_ids is None or resultMap['iri_id'] in iri_ids: |
|
111 elem = doc.createElement('seg') |
|
112 elem.setAttribute('idctt', resultMap['iri_id']) |
|
113 elem.setAttribute('idens', resultMap['ensemble_id']) |
|
114 elem.setAttribute('iddec', resultMap['decoupage_id']) |
|
115 elem.setAttribute('idseg', resultMap['element_id']) |
|
116 elem.setAttribute('idvue', "") |
|
117 elem.setAttribute('crit', "") |
|
118 doc.documentElement.appendChild(elem) |
|
119 |
|
120 return HttpResponse(doc.toprettyxml(encoding='utf-8'), mimetype="text/xml;charset=utf-8") |
|
121 |
|
122 @login_required |
|
123 def list_ldt(request): |
|
124 contents = Content.objects.all() |
|
125 try: |
|
126 owner = Owner.objects.get(user=request.user) |
|
127 except: |
|
128 return HttpResponseRedirect(settings.LOGIN_URL) |
|
129 ldtProjects = Project.objects.filter(owner=owner) |
|
130 context={ |
|
131 'contents': contents, |
|
132 'ldtProjects': ldtProjects.reverse(), |
|
133 } |
|
134 return render_to_response('ldt/ldt/ldt_list.html', context, context_instance=RequestContext(request)) |
|
135 |
|
136 def create_ldt_view(request): |
|
137 if request.method == "POST" : |
|
138 form = LdtAddForm(request.POST) |
|
139 if form.is_valid(): |
|
140 user = request.user |
|
141 Project.create_project(title=form.cleaned_data['title'], user=user, contents=form.cleaned_data['contents']) |
|
142 return HttpResponseRedirect(reverse("ldt.ldt_utils.views.list_ldt")) |
|
143 else: |
|
144 form = LdtAddForm() |
|
145 contents = Content.objects.all() |
|
146 return render_to_response('ldt/ldt/create_ldt.html', {'contents': contents, 'form': form,'create_project_action':reverse(create_ldt_view)}, context_instance=RequestContext(request)) |
|
147 |
|
148 def created_ldt(request): |
|
149 return render_to_response('ldt/ldt/done.html', context_instance=RequestContext(request)) |
|
150 |
|
151 def indexProject(request, id): |
|
152 |
|
153 urlStr = settings.WEB_URL + reverse("ldt.ldt_utils.views.init", args=['ldtProject', id]) |
|
154 posturl= settings.WEB_URL + reverse("ldt.ldt_utils.views.save_ldtProject") |
|
155 language_code = request.LANGUAGE_CODE[:2] |
|
156 |
|
157 ldt = get_object_or_404(Project, ldt_id=id) |
|
158 if ldt.state ==2: #published |
|
159 readonly = 'true' |
|
160 else: |
|
161 readonly = 'false' |
|
162 |
|
163 return render_to_response('ldt/ldt/init_ldt.html', {'MEDIA_URL': settings.MEDIA_URL, 'colorurl': settings.MEDIA_URL+'swf/ldt/pkg/color.xml', 'i18nurl': settings.MEDIA_URL+'swf/ldt/pkg/i18n', 'language': language_code, 'baseurl': settings.MEDIA_URL+'swf/ldt/', 'url': urlStr, 'posturl': posturl, 'id': id, 'readonly': readonly}, context_instance=RequestContext(request)) |
|
164 |
|
165 def init(request, method, url): |
|
166 ldtgen = LdtUtils() |
|
167 |
|
168 doc = ldtgen.generateInit([url], 'ldt.ldt_utils.views.'+method, None) |
|
169 |
|
170 resp = HttpResponse(mimetype="text/xml") |
|
171 resp['Cache-Control']='no-cache, must-revalidate' |
|
172 resp['Pragma']='no-cache' |
|
173 xml.dom.ext.PrettyPrint(doc, resp) |
|
174 return resp |
|
175 |
|
176 def ldtProject(request, id): |
|
177 resp = HttpResponse(mimetype="text/xml") |
|
178 resp['Cache-Control']='no-cache, must-revalidate' |
|
179 resp['Pragma']='no-cache' |
|
180 |
|
181 project = Project.objects.get(ldt_id=id) |
|
182 resp.write(project.ldt) |
|
183 return resp |
|
184 |
|
185 def save_ldtProject(request): |
|
186 if request.method=="POST": |
|
187 ldt = request.POST['ldt'] |
|
188 id = request.POST['id'] |
|
189 ldtproject=Project.objects.get(ldt_id=id) |
|
190 #save xml ldt |
|
191 ldtproject.ldt=ldt |
|
192 #get new title |
|
193 dom = xml.dom.minidom.parseString(ldt.encode( "utf-8" )) |
|
194 con = xml.xpath.Context.Context(dom, 1, 1, None) |
|
195 result = xml.xpath.Evaluate("/iri/project",context=con) |
|
196 for pnode in result: |
|
197 title=pnode.getAttribute("title") |
|
198 break |
|
199 #set new title |
|
200 ldtproject.title=title |
|
201 #get new content list |
|
202 new_contents=[] |
|
203 result = xml.xpath.Evaluate("/iri/medias/media", context=con) |
|
204 for medianode in result: |
|
205 id = medianode.attributes['id'].value |
|
206 new_contents.append(id) |
|
207 # set new content list |
|
208 for c in ldtproject.contents.all(): |
|
209 if not c.iri_id in new_contents: |
|
210 ldtproject.contents.remove(c) |
|
211 ldtproject.save() |
|
212 else: |
|
213 ldt = '' |
|
214 return render_to_response('ldt/ldt/save_done.html', {'ldt': ldt, 'id':id, 'title':title, 'contents': new_contents}, context_instance=RequestContext(request)) |
|
215 |
|
216 @login_required |
|
217 def publish(request, id): |
|
218 ldt = get_object_or_404(Project, ldt_id=id) |
|
219 ldt.state = 2 #published |
|
220 ldt.save() |
|
221 return HttpResponseRedirect(reverse("ldt.ldt_utils.views.list_ldt")) |
|
222 |
|
223 @login_required |
|
224 def unpublish(request, id): |
|
225 ldt = get_object_or_404(Project, ldt_id=id) |
|
226 ldt.state = 1 #edition |
|
227 ldt.save() |
|
228 return HttpResponseRedirect(reverse("ldt.ldt_utils.views.list_ldt")) |
|
229 |
|
230 |
|
231 def index(request, url): |
|
232 |
|
233 urlStr = settings.WEB_URL + django.core.urlresolvers.reverse("ldt.ldt_utils.views.init", args=['ldt',url]) |
|
234 language_code = request.LANGUAGE_CODE[:2] |
|
235 |
|
236 return render_to_response('ldt/ldt/init_ldt.html', {'MEDIA_URL': settings.MEDIA_URL, 'colorurl': settings.MEDIA_URL+'swf/ldt/pkg/color.xml', 'i18nurl': settings.MEDIA_URL+'swf/ldt/pkg/i18n', 'language': language_code, 'baseurl': settings.MEDIA_URL+'swf/ldt/', 'url': urlStr, 'weburl':settings.WEB_URL+settings.BASE_URL}, context_instance=RequestContext(request)) |
|
237 |
|
238 |
|
239 def ldt(request, url, startSegment = None): |
|
240 |
|
241 import Ft |
|
242 from Ft.Xml import MarkupWriter |
|
243 |
|
244 resp = HttpResponse(mimetype="text/xml; charset=utf-8") |
|
245 resp['Cache-Control'] = 'no-cache' |
|
246 |
|
247 contentList = Content.objects.filter(iri_id=url) |
|
248 |
|
249 ldtgen = LdtUtils() |
|
250 ldtgen.generateLdt(contentList, file=resp, title = contentList[0].title, startSegment=startSegment) |
|
251 |
|
252 return resp |
|
253 |
|
254 |
|
255 def loading(request): |
|
256 return render_to_response('ldt/ldt/loading.html', context_instance=RequestContext(request)) |
|
257 |
|
258 |
|
259 @login_required |
|
260 def create_project(request, iri_id): |
|
261 |
|
262 content = get_object_or_404(Content, iri_id=iri_id) |
|
263 contents = [ content, ] |
|
264 if request.method == "POST" : |
|
265 form = AddProjectForm(request.POST) |
|
266 if form.is_valid(): |
|
267 user=request.user |
|
268 project = Project.create_project(title=form.cleaned_data['title'], user=user, contents=contents) |
|
269 return HttpResponseRedirect(reverse('ldt.ldt_utils.views.indexProject', args=[project.ldt_id])) |
|
270 else: |
|
271 form = AddProjectForm() |
|
272 return render_to_response('ldt/ldt/create_ldt.html', {'form':form, 'contents':contents, 'iri_id':iri_id, 'create_project_action':reverse("ldt.ldt_utils.views.create_project",args=[iri_id])}, context_instance=RequestContext(request)) |
|
273 |
|
274 @login_required |
|
275 def copy_project(request, ldt_id): |
|
276 |
|
277 project = get_object_or_404(Project, ldt_id=ldt_id) |
|
278 if request.method == "POST" : |
|
279 form = CopyProjectForm(request.POST) |
|
280 if form.is_valid(): |
|
281 user=request.user |
|
282 project = project.copy_project(title=request.POST['title'], user=user) |
|
283 return HttpResponseRedirect(reverse('ldt.ldt_utils.views.indexProject', args=[project.ldt_id])) |
|
284 else: |
|
285 form = CopyProjectForm |
|
286 return render_to_response('ldt/ldt/copy_ldt.html', {'form':form, 'project':project}, context_instance=RequestContext(request)) |
|
287 |