diff -r 85b071fb75b2 -r eb9188f2ee4f web/ldt/ldt_utils/views.py
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/web/ldt/ldt_utils/views.py	Fri Oct 22 18:14:30 2010 +0200
@@ -0,0 +1,809 @@
+from contentindexer import *
+from django.conf import settings
+from django.contrib.auth.decorators import login_required
+from django.core import serializers
+from django.core.urlresolvers import reverse
+from django.db.models import Q
+from django.forms.forms import get_declared_fields
+from django.forms.models import model_to_dict
+from django.forms.util import ErrorList
+from django.http import HttpResponse, HttpResponseRedirect, \
+    HttpResponseForbidden, HttpResponseServerError
+from django.shortcuts import render_to_response, get_object_or_404, \
+    get_list_or_404
+from django.template import RequestContext
+from django.template.loader import render_to_string
+from django.utils import simplejson
+from django.utils.html import escape
+from django.utils.translation import ugettext as _, ungettext
+from fileimport import *
+from forms import LdtImportForm, LdtAddForm, SearchForm, AddProjectForm, \
+    CopyProjectForm, ContentForm, MediaForm
+from ldt.core.models import Owner
+from ldt.ldt_utils.models import Content, Project, Owner
+from ldt.ldt_utils.projectserializer import ProjectSerializer
+from ldt.ldt_utils.utils import boolean_convert
+from lxml import etree
+from lxml.html import fromstring, fragment_fromstring
+from models import *
+from projectserializer import *
+from string import Template
+from urllib2 import urlparse
+from utils import *
+import StringIO
+import base64
+import cgi
+import django.core.urlresolvers
+import ldt.auth as ldt_auth
+import ldt.utils.path as ldt_utils_path
+import logging
+import lucene
+import lxml.etree
+import tempfile
+import urllib2
+import uuid
+
+
+@login_required
+def workspace(request):
+
+    # list of contents
+    content_list = Content.objects.all()
+
+    # get list of projects
+    project_list = Project.objects.all()
+
+    # render list
+    return render_to_response("ldt/ldt_utils/workspace.html",
+                              {'contents': content_list, 'projects': project_list},
+                              context_instance=RequestContext(request))
+
+
+def popup_embed(request):
+
+    json_url = request.GET.get("json_url")
+    player_id = request.GET.get("player_id")
+    ldt_id = request.GET.get("ldt_id")
+
+
+    project = Project.objects.get(ldt_id=ldt_id);
+
+    if not ldt_auth.checkAccess(request.user, project):
+        return HttpResponseForbidden(_("You can not access this project"))
+
+    ps = ProjectSerializer(project, from_contents=False, from_display=True)
+    annotations = ps.getAnnotations(first_cutting=True)
+
+    embed_rendered = dict((typestr,
+                           (lambda s:escape(lxml.etree.tostring(fragment_fromstring(render_to_string("ldt/ldt_utils/partial/embed_%s.html"%(s), {'json_url':json_url,'player_id':player_id, 'annotations':annotations, 'ldt_id': ldt_id}, context_instance=RequestContext(request))),pretty_print=True)))(typestr))
+                           for typestr in ('player','seo_body', 'seo_meta', 'links')  )
+
+    return render_to_response("ldt/ldt_utils/embed_popup.html",
+                              {'json_url':json_url,'player_id':player_id, 'embed_rendered':embed_rendered, 'annotations':annotations},
+                              context_instance=RequestContext(request))
+
+
+
+@login_required
+def projectsfilter(request, filter, is_owner=False, status=0):
+
+    project_list = None
+    is_owner = boolean_convert(is_owner)
+    status = int(status)
+    query = Q()
+
+    if is_owner:
+        owner = None
+        try:
+            owner = Owner.objects.get(user=request.user)
+        except:
+            return HttpResponseServerError("<h1>User not found</h1>")
+        query &= Q(owner=owner)
+
+    if status > 0:
+        query &= Q(state=status)
+
+    if filter:
+        if len(filter) > 0 and filter[0] == '_':
+            filter = filter[1:]
+        query &= Q(title__icontains=filter)
+
+    project_list =  Project.objects.filter(query)
+
+    return render_to_response("ldt/ldt_utils/partial/projectslist.html",
+                              {'projects': project_list},
+                              context_instance=RequestContext(request))
+
+
+
+
+
+@login_required
+def contentsfilter(request, filter):
+    if filter and len(filter) > 0 and filter[0] == '_':
+        filter = filter[1:]
+
+    if filter:
+        content_list = Content.objects.filter(title__icontains=filter)
+    else:
+        content_list = Content.objects.all()
+
+    return render_to_response("ldt/ldt_utils/partial/contentslist.html",
+                              {'contents': content_list},
+                              context_instance=RequestContext(request))
+
+
+def searchForm(request):
+    form = SearchForm()
+    return render_to_response('ldt/ldt_utils/search_form.html',{'form': form} , context_instance=RequestContext(request))    
+
+def searchIndex(request):
+    
+    sform = SearchForm(request.POST)
+    if sform.is_valid():
+        search = sform.cleaned_data["search"]
+    
+    
+        queryStr = base64.urlsafe_b64encode(search.encode('utf8'))
+        field = request.POST["field"]
+        language_code = request.LANGUAGE_CODE[:2]
+    
+        url = settings.WEB_URL + django.core.urlresolvers.reverse("ldt.ldt_utils.views.searchInit", args=[field, queryStr])
+        return render_to_response('ldt/ldt_utils/init_ldt.html', {'LDT_MEDIA_PREFIX': settings.LDT_MEDIA_PREFIX, 'colorurl': settings.LDT_MEDIA_PREFIX+'swf/ldt/pkg/color.xml', 'i18nurl': settings.LDT_MEDIA_PREFIX+'swf/ldt/pkg/i18n', 'language': language_code, 'baseurl': settings.LDT_MEDIA_PREFIX+'swf/ldt/', 'url': url}, context_instance=RequestContext(request))
+    else:
+        resp = HttpResponse()
+        resp.write("<html><head></head><body>Error : No result</body></html>");
+
+def searchIndexGet(request, field, query):
+
+    language_code = request.LANGUAGE_CODE[:2]
+    url = settings.WEB_URL + django.core.urlresolvers.reverse("ldt.ldt_utils.views.searchInit", args=[field, query])
+    return render_to_response('ldt/ldt_utils/init_ldt.html', {'LDT_MEDIA_PREFIX': settings.LDT_MEDIA_PREFIX, 'colorurl': settings.LDT_MEDIA_PREFIX+'swf/ldt/pkg/color.xml', 'i18nurl': settings.LDT_MEDIA_PREFIX+'swf/ldt/pkg/i18n', 'language': language_code, 'baseurl': settings.LDT_MEDIA_PREFIX+'swf/ldt/', 'url': url}, context_instance=RequestContext(request))
+
+def searchInit(request, field, query):
+    
+    ldtgen = LdtUtils()
+    
+    doc = ldtgen.generateInit([field,query], 'ldt.ldt_utils.views.searchLdt', 'ldt.ldt_utils.views.searchSegments')
+    
+    resp = HttpResponse(mimetype="text/xml;charset=utf-8")
+    doc.write(resp, pretty_print=True)
+    return resp
+
+def searchLdt(request, field, query, edition=None):
+    
+    contentList = []
+    resp = HttpResponse(mimetype="text/xml")
+    queryStr = ""
+
+    if query and len(query)>0:        
+        queryStr = base64.urlsafe_b64decode(query.encode("ascii")).decode("utf8")
+        searcher = LdtSearch()
+        ids = {}
+        
+        for result in searcher.query(field, queryStr):
+            ids[result["iri_id"]] = ""            
+
+        id_list = ids.keys()
+        
+        if edition is not None:
+            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")))            
+            id_list = filter(lambda id: id in id_list, ids_editions)
+            
+        contentList = Content.objects.filter(iri_id__in=id_list)        
+
+            
+    ldtgen = LdtUtils()
+    ldtgen.generateLdt(contentList, file=resp, title = u"Recherche : " + queryStr)
+    
+    return resp
+
+
+def searchSegments(request, field, query, edition=None):
+    
+    if query and len(query)>0:
+        searcher = LdtSearch()
+        
+        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 = etree.SubElement(iri, 'seg')
+	    seg.set('idctt', resultMap['iri_id'])
+            seg.set('idens', resultMap['ensemble_id'])
+            seg.set('iddec', resultMap['decoupage_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") 
+
+
+
+@login_required         
+def list_ldt(request):
+    contents = Content.objects.all()
+    try:
+        owner = Owner.objects.get(user=request.user)
+    except:
+        return HttpResponseRedirect(settings.LOGIN_URL)
+    ldtProjects = Project.objects.filter(owner=owner)
+    context={
+    'contents': contents,
+    'projects': ldtProjects.reverse(),
+    }
+    return render_to_response('ldt/ldt_utils/ldt_list.html', context, context_instance=RequestContext(request))
+
+@login_required         
+def list_content(request):
+    contents = Content.objects.all()
+    context={
+        'contents': contents,
+    }
+    return render_to_response('ldt/ldt_utils/content_list.html', context, context_instance=RequestContext(request))
+
+@login_required
+def create_ldt_view(request):
+    if request.method == "POST" :
+        form = LdtAddForm(request.POST)
+        if form.is_valid():
+            user = request.user
+            Project.create_project(title=form.cleaned_data['title'], user=user, contents=form.cleaned_data['contents'])
+            form_status = "saved"
+            contents=[]
+            #return HttpResponseRedirect(reverse("ldt.ldt_utils.views.list_ldt"))
+    else:
+        form = LdtAddForm()
+        contents = Content.objects.all()
+        form_status = "none"
+            
+    return render_to_response('ldt/ldt_utils/create_ldt.html', {'contents': contents, 'form': form, 'form_status':form_status,'create_project_action':reverse(create_ldt_view)}, context_instance=RequestContext(request))
+     
+def created_ldt(request):
+    return render_to_response('ldt/ldt_utils/save_done.html', context_instance=RequestContext(request))
+    
+def indexProject(request, id):
+
+    urlStr = settings.WEB_URL + reverse("space_ldt_init", args=['ldtProject', id])
+    posturl= settings.WEB_URL + reverse("ldt.ldt_utils.views.save_ldtProject")
+    language_code = request.LANGUAGE_CODE[:2]
+    
+    ldt = get_object_or_404(Project, ldt_id=id)
+    if ldt.state ==2: #published
+        readonly = 'true'
+    else:
+        readonly = 'false'
+    
+    return render_to_response('ldt/ldt_utils/init_ldt.html', {'LDT_MEDIA_PREFIX': settings.LDT_MEDIA_PREFIX, 'colorurl': settings.LDT_MEDIA_PREFIX+'swf/ldt/pkg/color.xml', 'i18nurl': settings.LDT_MEDIA_PREFIX+'swf/ldt/pkg/i18n', 'language': language_code, 'baseurl': settings.LDT_MEDIA_PREFIX+'swf/ldt/', 'url': urlStr, 'posturl': posturl, 'id': id, 'readonly': readonly}, context_instance=RequestContext(request))
+    
+def init(request, method, url):
+    ldtgen = LdtUtils()
+
+    doc = ldtgen.generateInit([url], 'ldt.ldt_utils.views.'+method, None)
+
+    resp = HttpResponse(mimetype="text/xml")
+    resp['Cache-Control']='no-cache, must-revalidate'
+    resp['Pragma']='no-cache'
+
+    resp.write( etree.tostring(doc, pretty_print=True, xml_declaration=True, encoding="utf-8")) 
+    return resp
+       
+def ldtProject(request, id):
+    resp = HttpResponse(mimetype="text/xml")
+    resp['Cache-Control']='no-cache, must-revalidate'
+    resp['Pragma']='no-cache'
+    
+    project = Project.objects.get(ldt_id=id)
+    resp.write(project.ldt)
+    return resp
+
+
+def project_json_id(request, id):
+    
+    project = get_object_or_404(Project,ldt_id=id)
+
+    return project_json(request, project, False)
+
+
+def project_json_externalid(request, id):
+        
+    res_proj = get_list_or_404(Project.objects.order_by('-modification_date'),contents__external_id = id)
+    
+    return project_json(request, res_proj[0], False)
+
+
+
+def project_json(request, project, serialize_contents = True):
+    
+    if not ldt_auth.checkAccess(request.user, project):
+        return HttpResponseForbidden(_("You can not access this project"))
+        
+    mimetype = request.REQUEST.get("mimetype")
+    if mimetype is None:
+        mimetype = "application/json; charset=utf-8"
+    else:
+        mimetype = mimetype.encode("utf-8")
+    if "charset" not in mimetype:
+        mimetype += "; charset=utf-8" 
+    resp = HttpResponse(mimetype=mimetype)
+    resp['Cache-Control']='no-cache, must-revalidate'
+    resp['Pragma']='no-cache'
+    
+    indent = request.REQUEST.get("indent")
+    if indent is None:
+        indent = settings.LDT_JSON_DEFAULT_INDENT
+    else:
+        indent = int(indent)
+    
+    callback = request.REQUEST.get("callback")
+    escape_str = request.REQUEST.get("escape")
+    escape_bool = False
+    if escape_str:
+        escape_bool = {'true': True, 'false': False, "0": False, "1": True}.get(escape_str.lower())
+        
+        
+    ps = ProjectSerializer(project, serialize_contents)
+    project_dict = ps.serialize_to_cinelab()
+    
+    json_str = simplejson.dumps(project_dict, ensure_ascii=False, indent=indent)
+    
+    if callback is not None:
+        json_str = "%s(%s)" % (callback,json_str)
+    
+    if escape_bool:
+        json_str = escape(json_str)
+    
+    resp.write(json_str)
+
+    return resp
+
+def project_annotations_rdf(request, ldt_id):
+
+    project = Project.objects.get(ldt_id=ldt_id);
+    
+    if not ldt_auth.checkAccess(request.user, project):
+        return HttpResponseForbidden(_("You can not access this project"))
+
+    mimetype = request.REQUEST.get("mimetype")
+    if mimetype is None:
+        mimetype = "application/rdf+xml; charset=utf-8"
+    else:
+        mimetype = mimetype.encode("utf-8")
+    if "charset" not in mimetype:
+        mimetype += "; charset=utf-8" 
+    resp = HttpResponse(mimetype=mimetype)
+    resp['Cache-Control']='no-cache, must-revalidate'
+    resp['Pragma']='no-cache'
+
+    ps = ProjectSerializer(project, from_contents=False, from_display=True) 
+    annotations = ps.getAnnotations(first_cutting=True)
+    
+    rdf_ns = u"http://www.w3.org/1999/02/22-rdf-syntax-ns#"
+    dc_ns = u"http://purl.org/dc/elements/1.1/"
+    rdf = u"{%s}" % rdf_ns
+    dc = u"{%s}" % dc_ns
+    nsmap = {u'rdf' : rdf_ns, u'dc':dc_ns}
+    
+    rdf_root = etree.Element(rdf+u"RDF", nsmap=nsmap)
+    
+    logging.debug("RDF annotations : " + repr(annotations))
+    
+    for annotation in annotations:
+        uri = u""
+        if 'uri' in annotation and annotation['uri']:
+            uri = unicode(annotation['uri'])
+        annot_desc = etree.SubElement(rdf_root, rdf+u"Description")
+        annot_desc.set(rdf+u'about',uri)
+        if annotation['title']:
+            etree.SubElement(annot_desc, dc+'title').text = etree.CDATA(unicode(annotation['title']))
+        if annotation['desc']:
+            etree.SubElement(annot_desc, dc+'description').text = etree.CDATA(unicode(annotation['desc']))
+        if annotation['tags']:
+            for tag in annotation['tags']:
+                etree.SubElement(annot_desc, dc+'subject').text = etree.CDATA(unicode(tag))
+        etree.SubElement(annot_desc,dc+'coverage').text = u"start=%s, duration=%s" % (annotation['begin'], annotation['duration'])
+        
+    resp.write(u"<?xml version=\"1.0\" encoding=\"utf-8\"?>\n")
+    resp.write(u"<!DOCTYPE rdf:RDF PUBLIC \"-//DUBLIN CORE//DCMES DTD 2002/07/31//EN\" \"http://dublincore.org/documents/2002/07/31/dcmes-xml/dcmes-xml-dtd.dtd\">\n")
+    
+    resp.write(etree.tostring(rdf_root, xml_declaration=False, encoding="utf-8", pretty_print=True))
+
+    return resp
+
+def save_ldtProject(request):
+    if request.method=="POST":
+        ldt = request.POST['ldt']
+        id = request.POST['id']
+        ldtproject=Project.objects.get(ldt_id=id)
+
+	    #save xml ldt
+        ldtproject.ldt=ldt
+
+
+        doc = lxml.etree.fromstring(ldtproject.ldt.encode( "utf-8" ))
+        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:
+            id = medianode.get("id")
+            new_contents.append(id)
+    
+        #set new content list
+        for c in ldtproject.contents.all():
+            if not c.iri_id in new_contents:
+                ldtproject.contents.remove(c)
+    
+        ldtproject.save()
+    else:
+        ldt = ''
+        new_contents=[]
+    
+    return render_to_response('ldt/ldt_utils/save_done.html', {'ldt': ldt, 'id':id, 'title':ldtproject.title, 'contents': new_contents}, context_instance=RequestContext(request))
+
+
+
+@login_required    
+def publish(request, id, redirect=True):
+    ldt = get_object_or_404(Project, ldt_id=id)
+    ldt.state = 2 #published
+    ldt.save()
+    redirect = boolean_convert(redirect)
+    if redirect:
+        return HttpResponseRedirect(reverse("ldt.ldt_utils.views.list_ldt"))
+    else:
+        return HttpResponse(simplejson.dumps({'res':True, 'ldt': {'id': ldt.id, 'state':ldt.state,'ldt_id': ldt.ldt_id}}, ensure_ascii=False),mimetype='application/json')
+    
+@login_required    
+def unpublish(request, id, redirect=True):
+    ldt = get_object_or_404(Project, ldt_id=id)
+    ldt.state = 1 #edition
+    ldt.save()
+    redirect = boolean_convert(redirect)
+    if redirect:
+        return HttpResponseRedirect(reverse("ldt.ldt_utils.views.list_ldt"))
+    else:
+        return HttpResponse(simplejson.dumps({'res':True, 'ldt': {'id': ldt.id, 'state':ldt.state,'ldt_id': ldt.ldt_id}}, ensure_ascii=False),mimetype='application/json')
+    
+
+def index(request, url):
+    
+    urlStr = settings.WEB_URL + reverse("ldt_init", args=['ldt',url])
+    language_code = request.LANGUAGE_CODE[:2]
+    
+    return render_to_response('ldt/ldt_utils/init_ldt.html', {'LDT_MEDIA_PREFIX': settings.LDT_MEDIA_PREFIX, 'colorurl': settings.LDT_MEDIA_PREFIX+'swf/ldt/pkg/color.xml', 'i18nurl': settings.LDT_MEDIA_PREFIX+'swf/ldt/pkg/i18n', 'language': language_code, 'baseurl': settings.LDT_MEDIA_PREFIX+'swf/ldt/', 'url': urlStr, 'weburl':settings.WEB_URL+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.objects.filter(iri_id=url)
+
+    ldtgen = LdtUtils()
+    ldtgen.generateLdt(contentList, file=resp, title = contentList[0].title, startSegment=startSegment)
+
+    return resp
+
+
+def loading(request):
+     return render_to_response('ldt/ldt_utils/loading.html', context_instance=RequestContext(request))
+
+
+@login_required
+def create_project(request, iri_id):
+
+    content = get_object_or_404(Content, iri_id=iri_id)
+    contents = [ content, ]
+    if request.method == "POST" :
+        form = AddProjectForm(request.POST)
+        if form.is_valid():
+            user=request.user
+            project = Project.create_project(title=form.cleaned_data['title'], user=user, contents=contents)
+            return HttpResponseRedirect(reverse('ldt.ldt_utils.views.indexProject', args=[project.ldt_id]))
+    else:
+        form = AddProjectForm()
+    return render_to_response('ldt/ldt_utils/create_ldt.html', {'form':form, 'contents':contents, 'create_project_action':reverse("ldt.ldt_utils.views.create_project",args=[iri_id])}, context_instance=RequestContext(request))
+
+@login_required
+def update_project(request, ldt_id):
+
+    project = get_object_or_404(Project, ldt_id=ldt_id)
+    contents = project.contents.all()
+    if request.method == "POST" :
+        submit_action = request.REQUEST.get("submit_button",False)
+        if submit_action == "prepare_delete":
+            errors = []
+            if project.state == 2:
+                errors.append(_("the project %(title)s is published. please unpublish before deleting.")%{'title':project.title})
+                message = _("can not delete the project. Please correct the following error")
+                title =  _('title error deleting project')
+            else:
+                message = _("please confirm deleting project %(title)s")%{'title':project.title}
+                title = _("confirm deletion")
+            return render_to_response('ldt/ldt_utils/error_confirm.html', {'errors':errors, 'message':message, 'title': title}, context_instance=RequestContext(request))
+        elif submit_action == "delete":
+            if project.state != 2:
+                project.delete()
+            form_status= 'deleted'
+            form = AddProjectForm()
+        else:
+            form_status= 'saved'
+            form = AddProjectForm(request.POST)
+            if form.is_valid():
+                if project.title != form.cleaned_data['title']:
+                    project.title=form.cleaned_data['title']
+                    ldt = lxml.etree.fromstring(project.ldt.encode("utf-8"))
+                    res = ldt.xpath("/iri/project")
+                    res[0].set("title",project.title)
+                    project.ldt = lxml.etree.tostring(ldt,pretty_print=True)
+                    project.save()
+    else:
+        form = AddProjectForm({'title':unicode(project.title)})
+        form_status= 'none'
+        
+    return render_to_response('ldt/ldt_utils/create_ldt.html', {'form':form, 'form_status':form_status, 'ldt_id': ldt_id, 'contents':contents, 'create_project_action':reverse("ldt.ldt_utils.views.update_project",args=[ldt_id])}, context_instance=RequestContext(request))
+
+
+@login_required
+def copy_project(request, ldt_id):
+
+    project = get_object_or_404(Project, ldt_id=ldt_id)
+    if request.method == "POST" :
+        form = CopyProjectForm(request.POST)
+        if form.is_valid():
+            user=request.user
+            project = project.copy_project(title=request.POST['title'], user=user)
+            return HttpResponseRedirect(reverse('ldt.ldt_utils.views.indexProject', args=[project.ldt_id]))
+    else:
+        form = CopyProjectForm
+    return render_to_response('ldt/ldt_utils/copy_ldt.html', {'form':form, 'project':project}, context_instance=RequestContext(request))
+
+
+def write_content_base(request, iri_id=None):
+
+    if iri_id:        
+        instance_content = Content.objects.get(iri_id=iri_id)
+        instance_media = instance_content.media_obj
+        logging.debug("write_content_base : valid form: for instance : media -> " + repr(instance_media) + " content : for instance : " + repr(instance_content) ) 
+    else:
+        logging.debug("No iri_id")
+        instance_content = None
+        instance_media = None
+    
+    form_status= 'none'        
+    if request.method =="POST":
+        
+        content_instance_val = model_to_dict(instance_content,exclude=ContentForm.Meta.exclude)
+        media_instance_val = model_to_dict(instance_media, exclude=MediaForm.Meta.exclude)
+        #add prefix
+        
+        def add_prefix(dict, prefix):
+            for key,value in dict.items():
+                dict['%s-%s' % (prefix, key)] = value
+                del(dict[key])
+        
+        add_prefix(content_instance_val, "content")
+        add_prefix(media_instance_val, "media")        
+        
+        for k in request.POST.keys():
+            value = request.POST.get(k)
+            content_instance_val[k] = value
+            media_instance_val[k] = value
+        
+        content_form = ContentForm(content_instance_val, prefix="content", instance=instance_content)
+        media_form = MediaForm(media_instance_val, request.FILES, prefix="media", instance=instance_media)
+        
+        media_valid = media_form.is_valid()
+        content_valid = content_form.is_valid()
+        
+        logging.debug("write_content_base : valid form: for instance : " + repr(instance_media) + " -> media " + str(media_valid) +" content : for instance : " + repr(instance_content) + " : " + str(content_valid) )
+        
+        if media_valid and content_valid :
+            
+            # see if media must be created
+            cleaned_data = {}
+            cleaned_data.update(media_form.cleaned_data)
+
+            media_input_type = content_form.cleaned_data["media_input_type"]
+            
+            if media_input_type == "none":
+                media = None
+            elif media_input_type == "link":
+                media = content_form.cleaned_data["media_obj"]
+                created = False
+            elif media_input_type == "create":
+                del cleaned_data["media_file"]
+                if not cleaned_data['videopath']:
+                    cleaned_data['videopath'] = settings.STREAM_URL
+                media, created = Media.objects.get_or_create(src=cleaned_data['src'], defaults=cleaned_data)
+            elif media_input_type == "url" or  media_input_type == "upload" :                
+                # copy file
+                #complet src
+                destination_file = None
+                source_file = None
+                destination_file_path = None
+                try:
+                    if media_input_type == "url":
+                        url = cleaned_data["external_src_url"]
+                        source_file = urllib2.urlopen(url)
+                        source_filename = source_file.info().get('Content-Disposition', None)
+                        if not source_filename:
+                            source_filename = urlparse.urlparse(url).path.rstrip("/").split('/')[-1]
+                    elif media_input_type == "upload":
+                        source_file = request.FILES['media-media_file']
+                        source_filename = source_file.name
+                    
+                    source_filename = ldt_utils_path.sanitize_filename(source_filename)
+                    destination_filepath = os.path.join(settings.STREAM_PATH, source_filename)
+                    base_source_filename = source_filename
+                    extension = base_source_filename.split(".")[-1]
+                    if extension == base_source_filename:
+                        extension = ""
+                        base_basename_filename = base_source_filename
+                    else:
+                        base_basename_filename  =  base_source_filename[:-1 *(len(extension)+1)]
+                    i = 0
+                    while os.path.exists(destination_filepath):
+                        base_source_filename = "%s.%d.%s" % (base_basename_filename,i,extension)
+                        destination_filepath = os.path.join(settings.STREAM_PATH, base_source_filename)
+                        i += 1
+                        
+                    destination_file = open(destination_filepath, "w")
+                    src_prefix = settings.STREAM_SRC_PREFIX.rstrip("/")
+                    if len(src_prefix) > 0:
+                        cleaned_data["src"] = src_prefix + "/" + base_source_filename
+                    else:
+                        cleaned_data["src"] =  base_source_filename
+                    
+                    chunck = source_file.read(2048)
+                    while chunck:
+                        destination_file.write(chunck)
+                        chunck = source_file.read(2048)
+        
+                except Exception as inst:
+                    logging.debug("write_content_base : POST error when processing file:" + str(inst))
+                    form_status = "error"
+                    #set error for form
+                    if media_input_type == "url":
+                        errors = media_form._errors.setdefault("external_src_url", ErrorList())
+                        errors.append(_("Problem when downloading file from url : ")+str(inst))
+                    elif media_input_type == "upload":
+                        errors = media_form._errors.setdefault("media_file", ErrorList())
+                        errors.append(_("Problem when uploading file : ") + str(inst))
+                finally:
+                    if destination_file:
+                        destination_file.close()
+                    if source_file:
+                        source_file.close()
+                        
+                if form_status != "error":
+                    #try:
+                    del cleaned_data["media_file"]
+                    if not cleaned_data['videopath']:
+                        cleaned_data['videopath'] = settings.STREAM_URL
+                    media, created = Media.objects.get_or_create(src=cleaned_data['src'], defaults=cleaned_data)
+                else:
+                    media = None
+
+            if media and not created:                        
+                for attribute in ('external_id', 'external_permalink', 'external_publication_url', 'external_src_url', 'media_creation_date', 'videopath', 'duration', 'description', 'title'):
+                    setattr(media, attribute, cleaned_data.get(attribute))
+                media.save()
+                    #except Exception as inst:
+#                        logging.debug("write_content_base : POST error when saving media:" + str(inst))
+ #                       form_status = "error"
+                        #TODO: set error message
+                        #media_form.errors = _("Error when saving the media : " + e.message)
+
+            #if needed preparetemp file and copy temp file to destination
+            
+            
+            if form_status != "error":
+                #try:
+                content_defaults = {}
+                content_defaults.update(content_form.cleaned_data)
+                content_defaults['media_obj'] = media
+                del content_defaults["media_input_type"]
+                content, created = Content.objects.get_or_create(iri_id = content_form.cleaned_data['iri_id'], defaults = content_defaults)
+                if not created:
+                    
+                    for attribute in ('iriurl', 'title', 'description', 'duration', 'content_creation_date', 'tags', 'media_obj'):
+                        setattr(content, attribute, content_defaults[attribute])
+                content.save()
+                form_status = 'saved'
+                media_form = MediaForm(instance=media, prefix="media")
+                content_form = ContentForm(instance=content, prefix="content")
+                #except:
+                    #logging.debug("write_content_base : POST error when saving content:" + str(inst))
+                    #form_status = "error"
+                    #TODO : set error on content form
+        else:
+            form_status = 'error'
+    else:
+        form_status = 'empty'
+        initial = { 'media_input_type':"link"}
+        
+        content_form = ContentForm(prefix="content", instance=instance_content, initial = initial )
+        media_form = MediaForm(prefix="media", instance=instance_media)
+        
+        if instance_content is not None:
+            content_form.media_input_type = "link"
+    
+    return content_form, media_form, form_status
+
+@login_required
+def write_content(request, iri_id=None):
+    
+    submit_action = request.REQUEST.get("submit_button",False) 
+
+    if submit_action == "prepare_delete": 
+        errors, titles = prepare_delete_content(request, iri_id)
+        if errors and len(errors) > 0:
+            message = ungettext("There is %(count)d error when deleting content", "There are %(count)d errors when deleting content", len(errors)) % { 'count': len(errors)}
+            title_msg = _('title error deleting content')
+        else:
+            message = _("Confirm delete content %(titles)s") % { 'titles' : ",".join(titles) }
+            title_msg = _("confirm delete content")
+        return render_to_response('ldt/ldt_utils/error_confirm.html', {'errors':errors, 'message':message, 'title': title_msg}, context_instance=RequestContext(request))  
+    elif submit_action == "delete":
+        delete_content(request, iri_id)
+        form_status = "deleted"
+        content_form = ContentForm()
+        media_form = MediaForm()
+    else:
+        content_form, media_form, form_status = write_content_base(request, iri_id)
+
+    if iri_id:
+        create_content_action =  reverse('ldt.ldt_utils.views.write_content', kwargs={'iri_id':iri_id})
+    else:
+        create_content_action =  reverse('ldt.ldt_utils.views.write_content')
+    
+    return render_to_response('ldt/ldt_utils/create_content.html', {'content_form': content_form, 'media_form': media_form,'form_status': form_status,'create_content_action': create_content_action, 'iri_id': iri_id}, context_instance=RequestContext(request))
+
+@login_required
+def prepare_delete_content(request, iri_id=None):
+    errors = []
+    titles = []
+    if not iri_id:
+        iri_id = request.REQUEST.get("iri_id", None)
+        
+    if iri_id:
+        for content in Content.objects.filter(iri_id=iri_id):
+            titles.append(unicode(content.title))
+            projects = content.project_set.all()
+            projects_nb = len(projects)
+            if projects_nb > 0:
+                project_titles = map(lambda p: unicode(p.title), projects)
+                errors.append(ungettext("Content '%(title)s' is referenced by this project : %(project_titles)s. Please delete it beforehand.", "Content '%(title)s' is referenced by %(count)d projects: %(project_titles)s. Please delete them beforehand.", projects_nb)%{'title':unicode(content.title),'count':projects_nb, 'project_titles': ",".join(project_titles)})
+ 
+        
+    return errors, titles
+
+
+@login_required
+def delete_content(request, iri_id=None):
+    if not iri_id:
+        iri_id = request.REQUEST.get("iri_id", None)
+        
+    if iri_id:
+        Content.objects.filter(iri_id=iri_id).delete()
+