from django.conf import settings
from django.contrib.auth.decorators import login_required
from django.core.urlresolvers import reverse
from django.http import HttpResponse, HttpResponseRedirect
from django.shortcuts import render_to_response, get_object_or_404
from django.template import RequestContext
from ldt.indexation import SimpleSearch
from ldt.ldt_utils.models import Content, Project, Media
from ldt.ldt_utils.searchutils import search_generate_ldt
from ldt.ldt_utils.stat import update_stat_project
from ldt.ldt_utils.utils import LdtUtils, clean_description
from ldt.security.utils import set_forbidden_stream
from ldt.security.permissionchecker import check_object_perm_for_user
from ldt.utils.projectldt_parser import absolute_src_xml, relative_src_xml
from ldt.utils.url import absstatic, absurl
from ldt.utils.web_url_management import get_web_url
import base64
import lxml.etree
def search_index_get(request, field, query):
language_code = request.LANGUAGE_CODE[:2]
url = absurl(request, "ldt.ldt_utils.views.lignesdetemps.search_init", args=[field, query])
colorurl=absstatic(request, "ldt/swf/ldt/pkg/color.xml")
i18nurl=absstatic(request, "ldt/swf/ldt/pkg/i18n")
baseurl=absstatic(request, "ldt/swf/ldt/")
return render_to_response('ldt/ldt_utils/init_ldt.html', {'colorurl': colorurl, 'i18nurl': i18nurl, 'language': language_code, 'baseurl': baseurl, 'url': url}, context_instance=RequestContext(request))
def search_init(request, field, query):
ldtgen = LdtUtils()
doc = ldtgen.generate_init([field, query], 'ldt.ldt_utils.views.lignesdetemps.search_ldt', 'ldt.ldt_utils.views.lignesdetemps.search_segments')
resp = HttpResponse(mimetype="text/xml;charset=utf-8")
resp.write(lxml.etree.tostring(doc, pretty_print=True, encoding="utf-8"))
return resp
def search_ldt(request, field, query, edition=None, return_project=False, query_encoded=True):
resp = HttpResponse(mimetype="text/xml")
doc, _ = search_generate_ldt(request, field, query)
doc = absolute_src_xml(doc)
doc.write(resp, pretty_print=True)
return resp
def search_segments(request, field, query, edition=None):
if query and len(query) > 0:
searcher = SimpleSearch()
queryStr = base64.urlsafe_b64decode(query.encode("ascii")).decode("utf8")
res = searcher.query(field, queryStr)
else:
res = []
iri_ids = None
#if edition is not None:
# 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")))
iri = lxml.etree.Element('iri')
doc = lxml.etree.ElementTree(iri)
for resultMap in res:
if iri_ids is None or resultMap['iri_id'] in iri_ids:
seg = lxml.etree.SubElement(iri, 'seg')
seg.set('idctt', resultMap['iri_id'])
seg.set('idens', resultMap['ensemble_id'])
seg.set('iddec', resultMap['cutting_id'])
seg.set('idseg', resultMap['element_id'])
seg.set('idvue', "")
seg.set('crit', "")
#return doc
return HttpResponse(lxml.etree.tostring(doc, pretty_print=True), mimetype="text/xml;charset=utf-8")
def index_segment(request, project_id, content_id, cutting_id, ensemble_id, segment_id):
url_str = absurl(request, "ldt.ldt_utils.views.lignesdetemps.init_segment", args=[project_id, content_id, ensemble_id, cutting_id, segment_id])
post_url = ""
language_code = request.LANGUAGE_CODE[:2]
readonly = 'true'
template_path = 'ldt/ldt_utils/init_ldt.html'
colorurl=absstatic(request, "ldt/swf/ldt/pkg/color.xml")
i18nurl=absstatic(request, "ldt/swf/ldt/pkg/i18n")
baseurl=absstatic(request, "ldt/swf/ldt/")
return render_to_response(template_path, {'colorurl': colorurl, 'i18nurl': i18nurl, 'language': language_code, 'baseurl': baseurl, 'url': url_str, 'posturl': post_url, 'id': id, 'readonly': readonly}, context_instance=RequestContext(request))
def init_segment(request, project_id, content_id, ensemble_id, cutting_id, segment_id):
if project_id != u"_":
get_object_or_404(Project.safe_objects, ldt_id=project_id)
ldtgen = LdtUtils()
doc = ldtgen.generate_init([project_id, content_id, ensemble_id, cutting_id, segment_id], 'ldt.ldt_utils.views.lignesdetemps.ldt_segment', 'ldt.ldt_utils.views.lignesdetemps.highlight_segment')
return HttpResponse(lxml.etree.tostring(lxml.etree.ElementTree(doc), pretty_print=True), mimetype="text/xml;charset=utf-8")
def highlight_segment(request, project_id, content_id, ensemble_id, cutting_id, segment_id):
if project_id != u"_":
get_object_or_404(Project.safe_objects, ldt_id=project_id)
iri = lxml.etree.Element('iri')
doc = lxml.etree.ElementTree(iri)
seg = lxml.etree.SubElement(iri, 'seg')
seg.set('idctt', content_id)
seg.set('idens', ensemble_id)
seg.set('iddec', cutting_id)
seg.set('idseg', segment_id)
seg.set('idvue', "")
seg.set('crit', "")
return HttpResponse(lxml.etree.tostring(doc, pretty_print=True), mimetype="text/xml;charset=utf-8")
def ldt_segment(request, project_id, content_id, ensemble_id, cutting_id, segment_id):
resp = HttpResponse(mimetype="text/xml")
resp['Cache-Control'] = 'no-cache, must-revalidate'
resp['Pragma'] = 'no-cache'
if project_id and project_id != "_" :
project = Project.safe_objects.get(ldt_id=project_id) #@UndefinedVariable
ldtdoc = lxml.etree.fromstring(project.ldt_encoded)
ldtdoc = absolute_src_xml(ldtdoc)
ldtdoc = set_forbidden_stream(ldtdoc, request.user)
displays_node = ldtdoc.find("displays")
if not displays_node:
displays_node = lxml.etree.SubElement(ldtdoc, u"displays")
res = displays_node.xpath("display")
if len(res) > 0:
display_node = res[0]
else:
display_node = lxml.etree.SubElement(displays_node, u"display", attrib={u'id':u'0', u'title': u'generated', u'idsel':unicode(content_id), u'tc':u'0'})
res = display_node.xpath("content[@id='%s']/decoupage[(@id='%s') and (@idens='%s')]" % (content_id, cutting_id, ensemble_id))
if len(res) == 0:
#create node
res = display_node.xpath("content[@id='%s']" % (content_id))
if len(res) == 0:
content_node = lxml.etree.SubElement(display_node, u"content")
else:
content_node = res[0]
lxml.etree.SubElement(content_node, u"decoupage", attrib={u'id':unicode(cutting_id), u'idens':unicode(ensemble_id)})
active_segment_node = displays_node.find(u"activeSegment")
if not active_segment_node:
active_segment_node = lxml.etree.SubElement(displays_node, u"activeSegment")
id_node = active_segment_node.find(u"id")
if id_node:
active_segment_node.remove(id_node)
lxml.etree.SubElement(active_segment_node, u"id", attrib={u"idctt":unicode(content_id), u"idens": unicode(ensemble_id), "idcut":unicode(cutting_id), u"idseg":unicode(segment_id)})
ldtdoc = set_forbidden_stream(ldtdoc, request.user)
resp.write(lxml.etree.tostring(ldtdoc, xml_declaration=True, encoding='utf-8', pretty_print=True))
else:
# generate ldt from
ldtgen = LdtUtils()
content_list = Content.safe_objects.filter(iri_id=content_id)
if request.user and request.user.username:
username = request.user.username
else:
username = "webuser"
start_segment = {
'idcontent': content_id,
'idgroup' : ensemble_id,
'idcutting' : cutting_id,
'idsegment' : segment_id
}
doc = ldtgen.generate_ldt(content_list, "segment : ", author=username, startSegment=start_segment)
doc = absolute_src_xml(doc)
doc = set_forbidden_stream(doc, request.user)
doc.write(resp, pretty_print=('DEBUG' in dir(settings) and settings.DEBUG))
return resp
@login_required
def index_project(request, id, full=False):
urlStr = absurl(request, "ldt.ldt_utils.views.lignesdetemps.init", args=['ldt_project', id])
posturl = absurl(request, "ldt.ldt_utils.views.lignesdetemps.save_ldt_project")
language_code = request.LANGUAGE_CODE[:2]
colorurl = absstatic(request, "ldt/swf/ldt/pkg/color.xml")
i18nurl = absstatic(request, "ldt/swf/ldt/pkg/i18n")
baseurl = absstatic(request, "ldt/swf/ldt/")
try:
ldt = Project.safe_objects.get(ldt_id=id)
except Project.DoesNotExist:
return HttpResponseRedirect(reverse("ldt.ldt_utils.views.workspace.home"))
if ldt.state == 2 or not check_object_perm_for_user(ldt, 'change_project', request.user):
readonly = 'true'
else:
readonly = 'false'
if full:
template_path = 'ldt/ldt_utils/init_ldt_full.html'
else:
template_path = 'ldt/ldt_utils/init_ldt.html'
return render_to_response(template_path, {'colorurl': colorurl, 'i18nurl': i18nurl, 'language': language_code, 'baseurl': baseurl, 'url': urlStr, 'posturl': posturl, 'id': id, 'readonly': readonly}, context_instance=RequestContext(request))
def embed_ldt(request, id):
# Almost identical to index_project but without login_required and less parameters
urlStr = absurl(request, "ldt.ldt_utils.views.lignesdetemps.init", args=['ldt_project', id])
posturl = ""
language_code = request.LANGUAGE_CODE[:2]
colorurl = absstatic(request, "ldt/swf/ldt/pkg/color.xml")
i18nurl = absstatic(request, "ldt/swf/ldt/pkg/i18n")
baseurl = absstatic(request, "ldt/swf/ldt/")
readonly = 'true'
template_path = 'ldt/ldt_utils/embed_ldt.html'
try:
ldt = Project.safe_objects.get(ldt_id=id)
except Project.DoesNotExist:
return HttpResponseRedirect(reverse("ldt.ldt_utils.views.workspace.home"))
return render_to_response(template_path, {'colorurl': colorurl, 'i18nurl': i18nurl, 'language': language_code, 'baseurl': baseurl, 'url': urlStr, 'posturl': posturl, 'id': id, 'readonly': readonly}, context_instance=RequestContext(request))
def init(request, method, url):
ldtgen = LdtUtils()
doc = ldtgen.generate_init([url], 'ldt.ldt_utils.views.lignesdetemps.' + method, None)
library = doc.xpath('/iri/files/library')[0]
for c in Content.safe_objects.all().select_related("media_obj"):
elem = lxml.etree.SubElement(library, 'file')
elem.set('src', c.iri_url())
if c.videopath :
elem.set('video', c.videopath)
else :
elem.set('video', '')
elem.set('title', c.title)
elem.set('author', '')
elem.set('category', '')
elem.set('pict', '')
elem.set('img', '')
resp = HttpResponse(mimetype="text/xml")
resp['Cache-Control'] = 'no-cache, must-revalidate'
resp['Pragma'] = 'no-cache'
resp.write(lxml.etree.tostring(doc, pretty_print=True, xml_declaration=True, encoding="utf-8"))
return resp
def ldt_project(request, id):
resp = HttpResponse(mimetype="text/xml")
resp['Cache-Control'] = 'no-cache, must-revalidate'
resp['Pragma'] = 'no-cache'
project = Project.safe_objects.get(ldt_id=id) #@UndefinedVariable
doc = lxml.etree.fromstring(project.ldt_encoded)
doc = set_forbidden_stream(doc, request.user)
doc = absolute_src_xml(doc)
resp.write(lxml.etree.tostring(doc, pretty_print=True, xml_declaration=True, encoding="utf-8"))
return resp
def save_ldt_project(request):
if request.method == "POST":
ldt = request.POST['ldt']
ldt_id = request.POST['id']
ldtproject = Project.safe_objects.select_related().get(ldt_id=ldt_id) #@UndefinedVariable
ldtxml=lxml.etree.fromstring(ldt)
#save xml ldt
ldt, _, _ = relative_src_xml(ldtxml)
ldt = lxml.etree.tostring(ldt, pretty_print=True)
ldtproject.ldt = ldt
doc = lxml.etree.fromstring(ldtproject.ldt_encoded)
result = doc.xpath("/iri/project")
#set new title
ldtproject.title = result[0].get("title")
#get new content list
new_contents = []
result = doc.xpath("/iri/medias/media")
for medianode in result:
media_id = medianode.get("id")
new_contents.append(media_id)
#Put back the video fied from "forbidden_stream_url" to the video url
if medianode.get("video") == settings.FORBIDDEN_STREAM_URL:
content = Content.objects.get(iri_id=media_id)
media = Media.objects.get(id=content.media_obj.id)
medianode.set('video', media.videopath)
ldtproject.ldt = lxml.etree.tostring(doc, pretty_print=True)
check_icon_project = False
#find contents to remove
for c in ldtproject.contents.all():
if not c.iri_id in new_contents:
ldtproject.contents.remove(c)
if ldtproject.image == c.image:
check_icon_project = True
#add new contents
contents_id = [c.iri_id for c in ldtproject.contents.all()]
for c in new_contents:
if c not in contents_id:
content = Content.objects.get(iri_id=c)
ldtproject.contents.add(content)
update_stat_project(ldtproject)
#remove html tags added by flash
description = ldtproject.get_description(doc)
new_desc = clean_description(description)
if new_desc:
desc_node = doc.xpath('/iri/project')[0]
desc_node.set('abstract', new_desc)
ldtproject.ldt = lxml.etree.tostring(doc, pretty_print=True)
ldtproject.description = new_desc if new_desc else description
#set a new icon for this project
if check_icon_project:
ldtproject.set_icon()
ldtproject.save()
else:
ldt = ''
new_contents = []
return render_to_response('ldt/ldt_utils/save_done.html', {'ldt': ldt, 'id':ldt_id, 'title':ldtproject.title, 'contents': new_contents}, context_instance=RequestContext(request))
def index(request, url):
urlStr = absurl(request, "ldt.ldt_utils.views.lignesdetemps.init", args=['ldt', url])
language_code = request.LANGUAGE_CODE[:2]
colorurl=absstatic(request, "ldt/swf/ldt/pkg/color.xml")
i18nurl=absstatic(request, "ldt/swf/ldt/pkg/i18n")
baseurl=absstatic(request, "ldt/swf/ldt/")
return render_to_response('ldt/ldt_utils/init_ldt.html', {'colorurl': colorurl, 'i18nurl': i18nurl, 'language': language_code, 'baseurl': baseurl, 'url': urlStr, 'weburl': get_web_url(request) + settings.BASE_URL}, context_instance=RequestContext(request))
def ldt(request, url, startSegment=None):
resp = HttpResponse(mimetype="text/xml; charset=utf-8")
resp['Cache-Control'] = 'no-cache'
contentList = Content.safe_objects.filter(iri_id=url) #@UndefinedVariable
ldtgen = LdtUtils()
doc = ldtgen.generate_ldt(contentList, title=contentList[0].title, startSegment=startSegment)
doc = set_forbidden_stream(doc, request.user)
doc = absolute_src_xml(doc)
doc.write(resp, pretty_print=True)
return resp