# Create your views here. from django.http import HttpResponse from django.shortcuts import render_to_response from django.template import RequestContext from enmi import settings from enmi.ldt.forms import LdtImportForm from enmi.ldt.forms import SearchForm, LdtForm, reindexForm from enmi.ldt.fileimport import * from enmi.conf.models import Edition, Speak, Content, Contribution from enmi.ldt.utils import * from iriuser.ldt.models import LdtProject from iriuser.ldt.projectindexer import ProjectIndexer import django.core.urlresolvers import django.utils.http import enmi.conf.models import enmi.utils.zipfileext import enmi.utils.fileext import enmi.utils.log import xml.dom.minidom import xml.dom.ext import base64 import cgi from enmi.ldt import STORE from enmi.ldt import ANALYZER import time def index(request, url): urlStr = settings.WEB_URL + django.core.urlresolvers.reverse("enmi.ldt.views.init", args=[url]) language_code = request.LANGUAGE_CODE[:2] return render_to_response('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)) def searchIriIds(field, edition, language_code, type, search, queryStr): searcher = enmi.ldt.utils.LdtSearch() resultList = searcher.query(field, type, search) #enmi.utils.log.debug("serchIriIds : " + repr(resultList)) ids = {} projects = {} for result in resultList: ids[result["iri_id"]] = "" project_id = result["ldt_id"] if project_id is not None and len(project_id)>0: projects[project_id] = "" id_list = ids.keys() project_list = projects.keys() if edition is not None and edition != 'all' : if type == "all" or type == "content": ids_editions_content = 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__content_base__iri_id"))) else: ids_editions_content = [] if (type == "all" or type == "project") and len(project_list) > 0: ids_editions_project = map(lambda t:t.iri_id,reduce(lambda t,u:t|set(u),map(lambda t:LdtProject.objects.get(id=t[0]).contents.all(),Contribution.objects.filter(edition=edition).values_list("ldtproject")),set())) contribution_list = list(Contribution.objects.select_related(depth=1).filter(edition=edition, ldtproject__ldt_id__in=project_list).order_by("ldtproject__creation_date")) else: ids_editions_project = [] contribution_list = [] ids_editions = list( set(ids_editions_content) | set(ids_editions_project)) id_list = filter(lambda id: id in id_list, ids_editions) else: if len(project_list) > 0: contribution_list = list(Contribution.objects.select_related(depth=1).filter(ldtproject__ldt_id__in=project_list).order_by("ldtproject__creation_date")) else: contribution_list = [] return (resultList,id_list, contribution_list) def searchIndex(request): sform = SearchForm(request.POST) if sform.is_valid(): search = sform.cleaned_data['search'] #search = request.POST["search"] queryStr = base64.urlsafe_b64encode(search.encode('utf8')) field = request.POST["field"] edition = request.POST["edition"] language_code = request.LANGUAGE_CODE[:2] type = request.POST["type"] ts = unicode(int(time.time()*1000)) search_res = searchIriIds(field, edition, language_code, type, search, queryStr) #enmi.utils.log.debug("SearchIndex params : " + repr(request.POST)) #enmi.utils.log.debug("SearchIndex resultList : " + repr(search_res[0])) #enmi.utils.log.debug("SearchIndex id_list : " + repr(search_res[1])) #enmi.utils.log.debug("SearchIndex contribution_list : " + repr(search_res[2])) id_list = search_res[1] else: id_list = [] if len(id_list)>0: url = settings.WEB_URL + django.core.urlresolvers.reverse("enmi.ldt.views.searchInit", args=[edition, field, type, queryStr]) resp = render_to_response('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, 'weburl':settings.WEB_URL+settings.BASE_URL, 'ts':ts}, context_instance=RequestContext(request)) resp['Cache-Control'] = 'no-cache' return resp else: return render_to_response('ldt/init_ldt_empty.html', None, context_instance=RequestContext(request)) def segmentIndex(request, iri_id, group_id, cutting_id, segment_id): urlStr = settings.WEB_URL + django.core.urlresolvers.reverse("enmi.ldt.views.segmentInit", args=[iri_id, group_id, cutting_id, segment_id]) language_code = request.LANGUAGE_CODE[:2] return render_to_response('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)) def searchInit(request, field, type, query, edition): ldtgen = enmi.ldt.utils.LdtUtils() doc = ldtgen.generateInit([edition,field, type,query], 'enmi.ldt.views.searchLdt', 'enmi.ldt.views.searchSegments') resp = HttpResponse(mimetype="text/xml") resp['Cache-Control'] = 'no-cache' xml.dom.ext.PrettyPrint(doc, resp) return resp def segmentInit(request, iri_id, group_id, cutting_id, segment_id): ldtgen = enmi.ldt.utils.LdtUtils() doc = ldtgen.generateInit([iri_id, group_id, cutting_id, segment_id], 'enmi.ldt.views.segmentLdt', 'enmi.ldt.views.segmentSegments') resp = HttpResponse(mimetype="text/xml") resp['Cache-Control'] = 'no-cache' xml.dom.ext.PrettyPrint(doc, resp) return resp def init(request, url): ldtgen = enmi.ldt.utils.LdtUtils() doc = ldtgen.generateInit([url], 'enmi.ldt.views.ldt', None) resp = HttpResponse(mimetype="text/xml") resp['Cache-Control'] = 'no-cache' xml.dom.ext.PrettyPrint(doc, resp) return resp def ldt(request, url, startSegment=None): import Ft from Ft.Xml import MarkupWriter resp = HttpResponse(mimetype="text/xml") resp['Cache-Control'] = 'no-cache' contentList = enmi.conf.models.Content.objects.filter(content_base__iri_id=url) ldtgen = enmi.ldt.utils.LdtUtils() ldtgen.generateLdt(contentList, file=resp, title = contentList[0].title, startSegment=startSegment) return resp def segmentLdt(request, iri_id, group_id, cutting_id, segment_id): return ldt(request, iri_id, startSegment={"idcontent":iri_id,"idgroup":group_id,"idcutting":cutting_id,"idsegment":segment_id}) def importFile(request): form = LdtImportForm() return render_to_response('ldt/upload_form.html',{'form': form} , context_instance=RequestContext(request)) def searchForm(request): form = SearchForm() return render_to_response('ldt/search_form.html',{'form': form} , context_instance=RequestContext(request)) def uploadFile(request): importform = LdtImportForm(request.POST, request.FILES) enmi.utils.log.debug(request.FILES) fi = FileImport(request.FILES['importFile']) fi.processFile() fi.close() return HttpResponse("File imported") def searchLdt(request, field, type, query, edition=None): contentList = [] resp = HttpResponse(mimetype="text/xml") resp['Cache-Control'] = 'no-cache' queryStr = "" resultList = [] language_code = request.LANGUAGE_CODE[:2] if query and len(query)>0: queryStr = base64.urlsafe_b64decode(query.encode("ascii")).decode("utf8") search = queryStr res_search = searchIriIds(field, edition, language_code, type, search, queryStr) id_list = res_search[1] resultList = res_search[0] contributionList = res_search[2] contentList = enmi.conf.models.Content.objects.filter(content_base__iri_id__in=id_list) ldtgen = enmi.ldt.utils.LdtUtils() ldtgen.generateLdt(contentList, contributions=contributionList, file=resp, title = u"Recherche : " + queryStr, resultList=resultList) return resp def searchSegments(request, field, type, query, edition=None): if query and len(query)>0: searcher = enmi.ldt.utils.LdtSearch() queryStr = base64.urlsafe_b64decode(query.encode("ascii")).decode("utf8") res = searcher.query(field, type, queryStr) else: res = [] iri_ids = None if edition is not None and edition != 'all': 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__content_base__iri_id"))) doc = xml.dom.getDOMImplementation().createDocument(None, "iri", None) for resultMap in res: if iri_ids is None or resultMap['iri_id'] in iri_ids: elem = doc.createElement('seg') elem.setAttribute('idctt', resultMap['iri_id']) elem.setAttribute('idens', resultMap['ensemble_id']) elem.setAttribute('iddec', resultMap['decoupage_id']) elem.setAttribute('idseg', resultMap['element_id']) elem.setAttribute('idvue', "") elem.setAttribute('crit', "") doc.documentElement.appendChild(elem) resp = HttpResponse(doc.toprettyxml(encoding='utf-8'), mimetype="text/xml") resp['Cache-Control'] = 'no-cache' return resp def segmentSegments(request, iri_id, group_id, cutting_id, segment_id): doc = xml.dom.getDOMImplementation().createDocument(None, "iri", None) elem = doc.createElement('seg') elem.setAttribute('idctt', iri_id) elem.setAttribute('idens', group_id) elem.setAttribute('iddec', cutting_id) elem.setAttribute('idseg', segment_id) elem.setAttribute('idvue', "") elem.setAttribute('crit', "") doc.documentElement.appendChild(elem) return HttpResponse(doc.toprettyxml(encoding='utf-8'), mimetype="text/xml") def downloadLdt(request): if request.method == "POST": edition_id = request.POST['edition'] user = request.POST['user'] edition = Edition.objects.get(id=edition_id).event_date.year resp = HttpResponse(mimetype="text/xml") resp['Content-Disposition'] = "attachment; filename=%s.ldt" % (edition,) ids = map(lambda t:t[0], filter(lambda id: id[0] is not None, Speak.objects.filter(session__day__edition=edition_id).order_by("session__start_ts", "order").values_list("content"))) rawContentList = Content.objects.in_bulk(ids) contentList = map(lambda id: rawContentList[id], ids) ldtgen = enmi.ldt.utils.LdtUtils() ldtgen.generateLdt(contentList, file=resp, author=user, title = "ENMI %s" % edition, web_url=settings.WEB_URL, media_url=settings.MEDIA_BASE_URL) return resp def exportForm(request): form = LdtForm() return render_to_response('ldt/export_form.html',{'form': form} , context_instance=RequestContext(request)) def reindex(request): message = None if request.method == "POST": form = reindexForm(request.POST) if form.is_valid(): try: writer = lucene.IndexWriter(STORE, ANALYZER, True) writer.setMaxFieldLength(1048576) message="" for edition in form.cleaned_data["editions"]: ids = map(lambda t:t[0], filter(lambda id: id[0] is not None, Speak.objects.filter(session__day__edition=edition.id).order_by("session__start_ts", "order").values_list("content"))) rawContentList = Content.objects.in_bulk(ids) contentList = map(lambda id: rawContentList[id], ids) indexer = ContentIndexer(contentList,writer) indexer.index_all() if request.POST.has_key('project'): if request.POST['project'] == 'project': projectList = LdtProject.objects.filter(state=LdtProject.PUBLISHED) indexer = ProjectIndexer(projectList,writer) indexer.index_all() message='Toutes les contributions' writer.close() message = "Indexation ok : " + repr(form.cleaned_data["editions"])+message form = reindexForm() except Exception, inst: non_field_errors = form.non_field_errors() non_field_errors.append("Error when reindexing : " + cgi.escape(repr(inst))) form._errors["__all__"] = non_field_errors #message = "ERROR : " + repr(non_field_errors) else: form = reindexForm() return render_to_response('ldt/reindex_form.html', {'form': form, 'message':message}, context_instance=RequestContext(request))