34 

    31 class LdtSearch(object):

    35 def normalize_tags(list):

    32 

    36     nlist=[]

    33     def query(self, field, query):

    37     for tag in list:

    34         indexSearcher = lucene.IndexSearcher(STORE)

    38         tag = tag.lower()

    35         queryParser = lucene.QueryParser(lucene.Version.LUCENE_30, field, lucene.FrenchAnalyzer(lucene.Version.LUCENE_30))

    39         nlist.append(tag)

    36         queryParser.setDefaultOperator(lucene.QueryParser.Operator.AND)

    40     taglist = dict().fromkeys(nlist).keys()    

    37         queryObj = queryParser.parse(query)

    41     

    38         hits = indexSearcher.search(queryObj, settings.LDT_MAX_SEARCH_NUMBER)

    42     return taglist

    39     

    43 

    40         res = []

    44 

    41         for hit in hits.scoreDocs:

    45 def create_empty_annotation():

    42             doc = indexSearcher.doc(hit.doc)

    43             res.append({"iri_id":doc.get("iri_id"),"ensemble_id":doc.get("ensemble_id"),"decoupage_id":doc.get("decoupage_id"), "element_id":doc.get("element_id")})

    44         indexSearcher.close()

    45         return res

    46 

    47     def queryAll(self, query):        

    48         return self.query("all", query)

    49 

    50 class LdtUtils(object):

    51     

    52     def generateLdt(self, contentList, file, title = u"", author=u"IRI Web", web_url=u"", media_url="", startSegment = None, contributions=None):

    53 

    54         iri = lxml.etree.Element(u'iri')

    55         doc = lxml.etree.ElementTree(iri)

    56     

    57         project = lxml.etree.SubElement(iri, u'project')

    58         project.set(u"id",unicode(str(uuid.uuid1())))

    59         project.set(u"title",unicode(title))

    60         project.set(u"user",author)

    61         project.set(u"abstract",u"")

    62     

    63         medias = lxml.etree.SubElement(iri, u"medias")

    64         for content in contentList:

    65             videopath = unicode(settings.STREAM_URL)

    66             if content.videopath :

    67                 videopath = unicode(content.videopath)

    68             media = lxml.etree.SubElement(medias, "media")

    69             media.set(u"id",content.iri_id)

    70             media.set(u"src",content.iri_url(web_url))

    71             media.set(u"video",videopath)

    72             media.set(u"pict",u"")

    73             media.set(u"extra",u"")

    74     

    75             if contributions is None:

    76                 contributions = []

    77             annotations_nodes = {}

    78             for contrib in contributions:

    79                 ldtdoc = lxml.etree.fromstring(contrib.ldtproject.ldt.encode("utf-8"))

    80                 res = ldtdoc.xpath("/iri/annotations/content")

    81     

    82                 for content in res:

    83                     contentid = content.get("id")

    84                     if annotations_nodes.has_key(contentid):

    85                         contentnode = annotations_nodes[contentid]

    86                     else:

    87                         contentnode = {"id":contentid, "ensembles":[]}

    88                         annotations_nodes[contentid]=contentnode

    89                     for ens in content.childNodes:

    90                         if ens.tag.endswith("ensemble"):

    91                             contentnode["ensembles"].append(ens.tag)

    92     

    93     

    94             if len(annotations_nodes) > 0:

    95                 annotations = lxml.etree.SubElement(iri, "annotations")

    96                 for content in contentList:

    97                     if content.content_base.iri_id in annotations_nodes:

    98                         contentnode = annotations_nodes[content.content_base.iri_id]

    99                         if contentnode is not None:

   100                             if len(contentnode["ensembles"])>0:

   101                                 content = lxml.etree.SubElement(annotation, "content")

   102                                 content.set("id",contentnode["id"])

   103                                 content.text = u""

   104                             else:

   105                                 content = lxml.etree.SubElement(annotation, "content")

   106                                 content.set("id",contentnode["id"])

   107     

   108             else:

   109                 annotations = lxml.etree.SubElement(iri, "annotations")

   110     

   111     

   112         displays = lxml.etree.SubElement(iri, "displays")

   113         if len(contentList) > 0:

   114             display = lxml.etree.SubElement(displays, "display")

   115             display.set(u"id",u"0")

   116             display.set(u"title",u"generated")

   117             display.set(u"idsel",contentList[0].iri_id)

   118             display.set(u"tc",u"0")

   119             for content in contentList:

   120                 contentd = lxml.etree.SubElement(display,"content")

   121                 contentd.set(u"id",content.iri_id)

   122                 filepath = urllib.urlopen(content.iri_url())

   123             

   124                 udoc = lxml.etree.parse(filepath)

   125                 res = udoc.xpath("/iri/body/ensembles/ensemble/decoupage")

   126                 for decoupagenode in res:

   127                     decoupage_id = decoupagenode.get(u"id")

   128                     ensemble_id = decoupagenode.getparent().get(u"id")

   129                     decoupage_id = decoupagenode.get(u"id")

   130                     ensemble_id = decoupagenode.getparent().get(u"id")

   131                     decoupage = lxml.etree.SubElement(contentd,"decoupage")

   132                     decoupage.set(u"id",decoupage_id)

   133                     decoupage.set(u"idens",ensemble_id)

   134             if startSegment is not None:

   135                 activeSegment = lxml.etree.SubElement(display,"activeSegment")

   136                 idas = lxml.etree.SubElement(activeSegment,"id")

   137                 idas.set(u"idctt",startSegment["idcontent"])

   138                 idas.set(u"idens" ,startSegment["idgroup"])

   139                 idas.set(u"idcut",startSegment["idcutting"])

   140                 idas.set(u"idseg",startSegment["idsegment"])

   141     

   142         edits = lxml.etree.SubElement(iri, "edits")

   143         

   144         doc.write(file, pretty_print=True)

   145 

   146 

   147     def generateInit(self, url, method, search=None):

   148                 

   149         iri = lxml.etree.Element('iri')

   150         impl = lxml.etree.ElementTree(iri)

   151  

   152         elementFiles = lxml.etree.SubElement(iri,'files')    

   153         elementInit = lxml.etree.SubElement(elementFiles, 'init')

   154         elementfile = lxml.etree.SubElement(elementInit, 'file')

   155             

   156         elementfile.set('src',settings.WEB_URL + django.core.urlresolvers.reverse(method, args=url))

   157         elementfile.set('display', '1')

   158         if(search):

   159             elementfile.set("segsel",settings.WEB_URL + django.core.urlresolvers.reverse(search, args=url))   

   160 

   161     

   162         # /*chemin video : tant que le serveur de media n'est pas up, */

   163         elementfile.set('video', settings.STREAM_URL)

   164         elementfile.set('pict', "")

   165         elementfile.set('extra', "")    

   166 

   167         elementRecent = lxml.etree.SubElement(elementFiles, 'recent')

   168         elementLibrary = lxml.etree.SubElement(elementFiles, 'library')

   169     

   170         username = ''

   171         id = ''

   172 

   173         elementUser = lxml.etree.SubElement(iri, 'user')

   174         elementUser.set('name', username)

   175         elementUser.set('id', id)

   176         

   177         return iri 

   178 

   179 

   180 

   181 def create_ldt(project, user):

   182     """create xml"""

   183 

   184     

   185     contentList = project.contents.all()

   186     

   187     # create a dom

    49     textannotation = lxml.etree.SubElement(iri, 'text-annotation')

   191     #node project

    50     id = lxml.etree.SubElement(textannotation,'id')

   192     elementProject = lxml.etree.SubElement(iri, 'project')

    51     uri = lxml.etree.SubElement(textannotation,'uri')

   193     

    52     tags = lxml.etree.SubElement(textannotation,'tags')

   194     elementProject.set('abstract', "")

    53     

   195     elementProject.set('title', project.title)

    54     content = lxml.etree.SubElement(textannotation,'content')

   196     elementProject.set('user', user.username)

    55     color = lxml.etree.SubElement(content,'color')

   197     elementProject.set('id', project.ldt_id)

    56     description = lxml.etree.SubElement(content,'description')

   198 

    57     title = lxml.etree.SubElement(content,'title')

   199     #node medias

    58     text = lxml.etree.SubElement(content,'text')

   200     elementMedias = lxml.etree.SubElement(iri, 'medias')

    59     

   201     

    60     meta = lxml.etree.SubElement(textannotation,'meta')

   202     idsel = None      

    61     contributor = lxml.etree.SubElement(meta, "contributor")

   203     for content in contentList:

    62     creator = lxml.etree.SubElement(meta, "creator")

   204         if not idsel:

    63     creationdate = lxml.etree.SubElement(meta, "created")

   205             idsel = content.iri_id

    64     updatedate = lxml.etree.SubElement(meta, "modified")

   206         elementMedia = lxml.etree.SubElement(elementMedias, 'media')

    65 

   207         elementMedia.set('id', content.iri_id)

    66     return doc

   208         elementMedia.set('src', content.iri_url())

    67 

   209 

   210         if content.videopath and content.videopath !="":

   211             elementMedia.set('video', content.videopath)

   212         else:

   213             elementMedia.set('video', settings.STREAM_URL)

   214         elementMedia.set('pict', "")

   215         elementMedia.set('extra', "")

   216 

   217     if not idsel:

   218         idsel = ""

   219 

   220     #node annotations

   221     elementAnnotations = lxml.etree.SubElement(iri, 'annotations')

   222     

   223     #node displays

   224     elementDisplays = lxml.etree.SubElement(iri, 'displays')

   225     elementDisplay = lxml.etree.SubElement(elementDisplays, 'display')

   226     elementDisplay.set('id', '0')

   227     elementDisplay.set('title', 'Init view')

   228     elementDisplay.set('idsel', idsel)

   229     elementDisplay.set('tc', '0')

   230     elementDisplay.set('zoom', '0')

   231     elementDisplay.set('scroll', '0')

   232     elementDisplay.set('infoBAB', '')

   233 

   234     

   235     #node content

   236     for content in contentList:

   237         elementContent = lxml.etree.SubElement(elementDisplay, 'content')

   238         elementContent.set('id', content.iri_id)

   239 

   240         if not 'http' in content.iriurl:

   241         #eg: "iiiielizabethrosse/ENMI08-III_elizabethrosse.iri"

   242             url = content.iri_url()

   243         else:

   244             url =content.iriurl

   245         file = urllib.urlopen(url)

   246         doc = lxml.etree.parse(file)

   247         res = doc.xpath("/iri/body/ensembles/ensemble/decoupage")        

   248 

   249         #node decoupage

   250         for decoupagenode in res:

   251             decoupage_id = decoupagenode.get(u"id")

   252             parent= decoupagenode.getparent()

   253             ensemble_id = parent.get(u"id")

   254             elementDecoupage = lxml.etree.SubElement(elementContent, 'decoupage')

   255             elementDecoupage.set('idens', ensemble_id)

   256             elementDecoupage.set('id', decoupage_id)

   257     

   258     #node edits

   259     elementEdits = lxml.etree.SubElement(iri, 'edits')

   260     

   261     #write dom in Project.ldt 

   262     project.ldt = lxml.etree.tostring(iri, pretty_print=True)

   263     

   264     #save Project

   265     project.save()

   266     return project        

   267 

   268 

   269 def copy_ldt(project, new_project, user):

   270     new_project.ldt_id = str(uuid.uuid1())

   271     new_project.created_by=user.username

   272     new_project.changed_by=user.username

   273     new_project.state = 1

   274     

   275     contentList=project.contents.all()

   276     

   277     """create xml"""

   278     

   279     ldt = lxml.etree.fromstring(project.ldt.encode("utf-8"))

   280     res = ldt.xpath("/iri/project")

   281     for elementProject in res:

   282         elementProject.set('abstract', "")

   283         elementProject.set('title', new_project.title)

   284         elementProject.set('user', user.username)

   285         elementProject.set('id', new_project.ldt_id)

   286         

   287     new_project.ldt = lxml.etree.tostring(ldt, pretty_print=True)

   288 

   289     #save Project

   290     new_project.save()

   291     return new_project

   292 

   293 def create_empty_iri(file, content, username):

   294     

   295     iri = lxml.etree.Element('iri')

   296     doc = lxml.etree.ElementTree(iri)

   297 

   298     head = lxml.etree.SubElement(iri, 'head')

   299     meta1 = lxml.etree.SubElement(head, 'meta')

   300     meta1.set(u'name', u'id')

   301     meta1.set(u'content', unicode(content.iri_id))

   302     meta2 = lxml.etree.SubElement(head, 'meta')

   303     meta2.set(u'name',u'title')

   304     meta2.set(u'content', unicode(content.title))

   305     meta3 = lxml.etree.SubElement(head, 'meta')

   306     meta3.set(u'name',u'abstract')

   307     meta3.set(u'content', unicode(content.description))

   308     meta4 = lxml.etree.SubElement(head, 'meta')

   309     meta4.set(u'name',u'author')

   310     meta4.set(u'content', unicode(username))

   311     meta5 = lxml.etree.SubElement(head, 'meta')

   312     meta5.set(u'name',u'contributor')

   313     meta5.set(u'content', unicode(username))

   314     meta6 = lxml.etree.SubElement(head, 'meta')

   315     meta6.set(u'name',u'date')

   316     meta6.set(u'content', unicode(datetime.date.today().isoformat()))

   317     meta7 = lxml.etree.SubElement(head, 'meta')

   318     meta7.set(u'name',u'copyright')

   319     meta7.set(u'content', u'IRI')

   320     meta8 = lxml.etree.SubElement(head, 'meta')

   321     meta8.set(u'name', u'type')

   322     meta8.set(u'content', u'video')

   323 

   324     body = lxml.etree.SubElement(iri, 'body')

   325     ensembles = lxml.etree.SubElement(body, 'ensembles')

   326     links = lxml.etree.SubElement(body, 'links')

   327 

   328     medias = lxml.etree.SubElement(body, 'medias')

   329 

   330     media1 = lxml.etree.SubElement(medias, 'media')

   331     media1.set(u'id',u'video')

   332     video = lxml.etree.SubElement(media1, 'video')

   333     video.set(u'src',unicode(content.stream_src))

   334     video.set(u'id',unicode(content.iri_id))

   335     video.set(u'dur',unicode(content.duration))

   336     video.set(u'begin',u'0')

   337 

   338     media2 = lxml.etree.SubElement(medias, 'media')

   339     media2.set(u'id',u'tool')

   340     tool = lxml.etree.SubElement(media2, 'tool')

   341 

   342     display = lxml.etree.SubElement(body, 'display')

   343 

   344     doc.write(file, pretty_print=True)

   345 

   346 

   347 def update_iri(filepath, content, username):

   348     

   349     # open xml

   350     doc = lxml.etree.parse(filepath)

   351     

   352     res = doc.xpath("/iri/head/meta")

   353     # update meta

   354     

   355     for meta_node in res:

   356         meta_name = meta_node.get("name")

   357         content_attr = None

   358         if meta_name == u'id':

   359             content_attr = unicode(content.iri_id)

   360         elif meta_name == u'title':

   361             content_attr = unicode(content.title)

   362         elif meta_name == u'abstract':

   363             content_attr = unicode(content.description)

   364         elif meta_name == u'contributor':

   365             content_attr = unicode(username)

   366         elif meta_name == u"date":

   367             content_attr = unicode(datetime.date.today().isoformat())

   368         if content_attr is not None:

   369             meta_node.set(u"content", content_attr)

   370 

   371     res = doc.xpath("/iri/body/medias/media[@id='video']/video")

   372     

   373     if len(res) > 0:

   374         video_node = res[0]

   375         video_node.set(u'src', unicode(content.stream_src))

   376         video_node.set(u'dur', unicode(content.duration))

   377         video_node.set(u'id', unicode(content.iri_id))

   378     # update video

   379     

   380     f = open(filepath, "w")

   381     try:

   382         doc.write(f, encoding="UTF-8", pretty_print=True, xml_declaration=True)

   383     finally:

   384         f.close()