import tempfile
import os.path
import shutil
from django.core.exceptions import ObjectDoesNotExist
from ldt.utils import zipfileext
from django.conf import settings
from models import Content
import xml.dom.minidom
import xml.dom.ext #@UnresolvedImport
import xml.xpath #@UnresolvedImport
import fnmatch
import uuid
import urllib
class FileImportError(Exception):
def __init__(self, value):
self.value = value
def __str__(self):
return repr(self.value)
def Property(func):
return property(**func())
class IriInfo(object):
def __init__(self, id, order, titledesc, basepath="", videopath=settings.STREAM_URL, decoupage_blacklist = settings.DECOUPAGE_BLACKLIST, flatten = True):
self.id = id
self.basepath = basepath
self.order = order
self.src = ""
self.annotations = None
self.videopath = videopath
self.videourl = ""
self.title = None
self.desc = None
self.duration = None
self.created = False
self.content = None
self.decoupage_blacklist = decoupage_blacklist
if self.decoupage_blacklist is None:
self.decoupage_blacklist = ()
self.flatten = flatten
def processIri(self):
# for just import a file ldt and get the title for every media
if 'http' in self.src:
url = urllib.urlopen(self.src)
doc = xml.dom.minidom.parse(url)
doc = Ft.Xml.Domlette.ConvertDocument(doc)
con = xml.xpath.Context.Context(doc, 1, 1, None)
#open .iri and get the title
res = xml.xpath.Evaluate("/iri/head/meta[@name='title']/@content", context=con)
self.title = res[0].value
#for import a zip, get title and copy file .iri in the media directory
else:
path = os.path.join(self.basepath, self.src)
doc = xml.dom.minidom.parse(path)
con = xml.xpath.Context.Context(doc, 1, 1, None)
res = xml.xpath.Evaluate("/iri/head/meta[@name='title']/@content", context=con)
self.title = res[0].value
res = xml.xpath.Evaluate("/iri/body/ensembles",context=con)
ensemblesnode = res[0]
ensembleids = []
for node in ensemblesnode.childNodes:
if node.nodeType == xml.dom.Node.ELEMENT_NODE and node.tagName == "ensemble":
id = node.getAttributeNS(None,u"id")
if id not in ensembleids:
ensembleids.append(id)
if self.annotations is not None:
newEnsemble = None
for cnode in self.annotations.childNodes:
if cnode.nodeType == xml.dom.Node.ELEMENT_NODE and cnode.tagName == "decoupage":
if newEnsemble is None:
newensemble = doc.createElement('ensemble')
ensembleid = self.id+"_"+str(uuid.uuid1())
newensemble.setAttributeNS(None,'id',ensembleid)
newensemble.setAttributeNS(None,'title', self.annotations.getAttribute('title'))
newensemble.setAttributeNS(None,'author', self.annotations.getAttribute('author'))
newensemble.setAttributeNS(None,'date', self.annotations.getAttribute('date'))
newensemble.setAttributeNS(None,'abstract', self.annotations.getAttribute('abstract'))
ensemblesnode.appendChild(newensemble)
ensembleids.append(ensembleid)
newDecoupageNode = cnode.cloneNode(True)
newensemble.appendChild(newDecoupageNode)
elif cnode.nodeType == xml.dom.Node.ELEMENT_NODE and cnode.tagName == "ensemble":
ensembleid = cnode.getAttribute(u"id")
cloneNode = cnode.cloneNode(True)
if ensembleid in ensembleids:
ensembleid = self.id+"_"+str(uuid.uuid1())
cloneNode.setAttribute(u"id", ensembleid)
ensembleids.append(ensembleid)
ensemblesnode.appendChild(cloneNode)
res = xml.xpath.Evaluate("/iri/body/medias/media[@id='video']/video", context=con)
if self.flatten:
src_video = res[0].getAttribute('src')
self.videourl = os.path.basename(src_video)
res[0].setAttributeNS(None,'src', self.videourl)
self.duration = res[0].getAttributeNS(None, u'dur')
f = open(path, "w")
try:
xml.dom.ext.Print(doc, stream=f)
finally:
f.close()
destPath = os.path.join(os.path.join(os.path.join(settings.MEDIA_ROOT, "media"), "ldt"), self.id);
if not os.path.exists(destPath):
os.makedirs(destPath)
shutil.move(os.path.join(self.basepath, self.src), os.path.join(destPath, os.path.basename(self.src)))
self.src = self.id + u"/" + os.path.basename(self.src)
def saveContent(self):
#if 'http' in self.src:
# url = self.src
#else:
# url = self.id + u"/" + os.path.basename(self.src)
content, self.created = Content.objects.get_or_create(iri_id=self.id, defaults = {'src':self.videourl, 'iriurl': self.src, 'title':self.title, 'description':self.desc, 'videopath': self.videopath})
if not self.created:
content.iriurl = self.src
content.title = self.title
content.description = self.desc
content.save()
content.iriurl = self.src
content.videopath = self.videopath.rstrip("/") + "/"
content.iri = self.id + u"/" + os.path.basename(self.src)
content.title = self.title
content.description = self.desc
content.duration = int(self.duration)
content.save()
self.content = content
def process(self):
self.processIri()
self.saveContent()
class BaseFileImport(object):
def __init__(self, filepath, videopath):
self.__filepath = filepath
self.__tempdir = ""
self.__videopath = videopath
self.__author = None
def filepath(): #@NoSelf
doc = """Docstring""" #@UnusedVariable
def fget(self):
return self.__filepath
def fset(self, value):
self.__filepath = value
def fdel(self):
del self.__filepath
return locals()
filepath = property(**filepath())
def videopath(): #@NoSelf
doc = """Docstring""" #@UnusedVariable
def fget(self):
return self.__videopath
def fset(self, value):
self.__videopath = value
def fdel(self):
del self.__videopath
return locals()
videopath = property(**videopath())
def author(): #@NoSelf
doc = """Docstring""" #@UnusedVariable
def fget(self):
return self.__author
def fset(self, value):
self.__author = value
def fdel(self):
del self.__author
return locals()
author = property(**author())
class FileImport(BaseFileImport):
def __init__(self, filepath, videopath, flatten):
BaseFileImport.__init__(self, filepath, videopath)
self.__checkExistingMedia = False
self.__flatten = flatten
def checkExistingMedia(): #@NoSelf
doc = """Docstring""" #@UnusedVariable
def fget(self):
return self.__checkExistingMedia
def fset(self, value):
self.__checkExistingMedia = value
def fdel(self):
del self.__checkExistingMedia
return locals()
checkExistingMedia = property(**checkExistingMedia())
def flatten(): #@NoSelf
doc = """Docstring""" #@UnusedVariable
def fget(self):
return self.__flatten
def fset(self, value):
self.__flatten = value
def fdel(self):
del self.__flatten
return locals()
flatten = property(**flatten())
def processLdt(self, ldtpath=None):
# list iri
# see if there is some comments
# inject comment in iri
# copy iri in folder
# create or update content
contents = {}
if ldtpath:
doc = xml.dom.minidom.parse(ldtpath)
else:
doc = xml.dom.minidom.parse(self.filepath)
con = xml.xpath.Context.Context(doc, 1, 1, None)
#get author from file ldt
result = xml.xpath.Evaluate("/iri/project", context=con)
for pnode in result:
author = pnode.getAttributeNS(None,u"user")
if author:
self.author = unicode(author)
break
result = xml.xpath.Evaluate("/iri/medias/media", context=con)
for i, medianode in enumerate(result):
# get iri file's id from file ldt
id = medianode.attributes['id'].value
if self.checkExistingMedia:
try:
Content.objects.get(iri_id=id)
do_pass = True
except ObjectDoesNotExist: #Content.DoesNotExist
do_pass = False
else:
do_pass = False
if not do_pass:
if not (contents.has_key(id)):
# Create instance iriInfo(id, order, titledesc, basepath="", videopath=settings.STREAM_URL)
if ldtpath:
contents[id] = IriInfo(id, i, "", os.path.dirname(ldtpath), flatten=self.flatten)
else:
contents[id] = IriInfo(id, i, "", flatten=self.flatten)
# Get iri file's url from ldt. This url can be relative path or absolute path.
contents[id].src = medianode.attributes['src'].value
if medianode.attributes['video'].value !="":
contents[id].videopath = medianode.attributes['video'].value
elif self.videopath !="" or self.videopath:
contents[id].videopath = self.videopath
else:
contents[id].videopath =settings.STREAM_URL
#get annotation of file ldt
result = xml.xpath.Evaluate("/iri/annotations/content", context=con)
for contentnode in result:
id = contentnode.attributes['id'].value
# pocketfilms.utils.log.debug("ID : " + str(id))
if contents.has_key(id):
if self.author:
contentnode.setAttributeNS(None,"author", unicode(self.author))
contents[id].annotations = contentnode
#go throught values
for iriinfo in contents.values():
iriinfo.process()
# if yes update
# if no create
# move iri file to the proper place
#return list of iriInfo
def processFile(self):
if self.filepath.name.endswith(".ldt"):
self.processLdt()
elif self.filepath.name.endswith(".zip"):
self.processZip()
else:
raise FileImportError("Bad file type")
def processZip(self):
# """ extraire .zip, pass to method processLdt"""
# create temp directory
self.__tempdir = tempfile.mkdtemp()
openfiles = []
flvfiles = []
processedids = []
try:
zipfile = zipfileext.ZipFileExt(self.filepath)
zipfile.unzip_into_dir(self.__tempdir)
#load ldt
foldersToProcess = [self.__tempdir]
while len(foldersToProcess):
# pocketfilms.utils.log.debug("folder stack length : "+ str(len(foldersToProcess)))
currentFolder = foldersToProcess.pop()
for entry in os.listdir(currentFolder):
if entry in settings.ZIP_BLACKLIST:
continue
entryPath = os.path.join(currentFolder, entry)
if(os.path.isdir(entryPath)):
# pocketfilms.utils.log.debug("Push folder : " + entryPath)
foldersToProcess.append(entryPath)
elif fnmatch.fnmatch(entry, "*.ldt"):
# pocketfilms.utils.log.debug("Process file : " + entryPath)
ldtid = self.processLdt(entryPath)
processedids.append(ldtid)
elif fnmatch.fnmatch(entry, "*.flv"):
flvfiles.append(entryPath)
if settings.CONTENT_ROOT and os.path.exists(settings.CONTENT_ROOT):
for entry in flvfiles:
shutil.copy(entry, settings.CONTENT_ROOT)
finally:
for f in openfiles:
f.close()
shutil.rmtree(self.__tempdir)
# delete directory
return processedids
# def processFileLdt(self):
# processedids = []
# ldtid = self.processLdt(self.filepath)
# processedids.append(ldtid)
# return processedids