def doTest(self, ExporterClass):
"""Exports a package with meta data"""
# Load our test package
package = Package.load('testPackage.elp')
# Do the export
outFilename = Path('scormtest.zip')
exporter = ExporterClass(self.app.config,
'../exe/webui/style/default',
outFilename)
exporter.export(package)
# Check that it made a nice zip file
assert outFilename.exists()
# See if the manifest file was created
zipped = ZipFile(outFilename)
filenames = zipped.namelist()
assert 'imsmanifest.xml' in filenames, filenames
self._testManifest(zipped.read('imsmanifest.xml'))
# Test that all the node's html files have been generated
pagenodes = Set([p.node for p in exporter.pages])
othernodes = Set(self._getNodes([], package.root))
assert pagenodes == othernodes
for page in exporter.pages:
self._testPage(page, zipped)
# Clean up
zipped.close()
def do_export(self, inputf, outputf):
if hasattr(self, 'export_' + self.options["export"]):
LOG.debug("Exporting to type %s, in: %s, out: %s, overwrite: %s" \
% (self.options["export"], inputf, outputf, str(self.options["overwrite"])))
if not outputf:
if self.options["export"] in ('website', 'singlepage'):
outputf = inputf.rsplit(".elp")[0]
else:
outputf = inputf + self.extensions[self.options["export"]]
outputfp = Path(outputf)
if outputfp.exists() and not self.options["overwrite"]:
error = _(u'"%s" already exists.\nPlease try again \
with a different filename') % outputf
raise Exception(error.encode(sys.stdout.encoding))
else:
if outputfp.exists() and self.options["overwrite"]:
if outputfp.isdir():
for filen in outputfp.walkfiles():
filen.remove()
outputfp.rmdir()
else:
outputfp.remove()
pkg = Package.load(inputf)
LOG.debug("Package %s loaded" % (inputf))
if not pkg:
error = _(u"Invalid input package")
raise Exception(error.encode(sys.stdout.encoding))
self.styles_dir = self.web_dir.joinpath('style', pkg.style)
LOG.debug("Styles dir: %s" % (self.styles_dir))
getattr(self, 'export_' + self.options["export"])(pkg, outputf)
return outputf
else:
raise Exception(_(u"Export format not implemented")\
.encode(sys.stdout.encoding))
def testExport(self):
# Delete the output dir
outdir = TempDirPath()
# Load a package
package = Package.load('testPackage.elp')
# Do the export
exporter = WebsiteExport('../exe/webui/style/default',
outdir,
'../exe/webui/images',
'../exe/webui/scripts',
'../exe/webui/templates')
exporter.export(package)
# Check that it all exists now
assert outdir.isdir()
assert (outdir / 'index.html').isfile()
# Check that the style sheets have been copied
for filename in Path('../exe/webui/style/default').files():
assert ((outdir / filename.basename()).exists(),
'Style file "%s" not copied' % (outdir / filename.basename()))
# Check that each node in the package has had a page made
pagenodes = Set([p.node for p in exporter.pages])
othernodes = Set(self._getNodes([], package.root))
assert pagenodes == othernodes
for page in exporter.pages:
self._testPage(page, outdir)
def createPackageFromTemplate(self, templateBase):
"""
Creates a new package from Template
"""
log.debug(u"createPackageFromTemplate")
package = Package.load(templateBase, isTemplate=True)
package.set_templateFile(str(templateBase.basename().splitext()[0]))
# Make up an initial unique name
i = 1
name = u"newPackage"
while name in self.loaded:
name = u"newPackage" + unicode(i)
i += 1
# Prevent the package from opening on the last node edited
package.currentNode = package.root
package.name = name
package.filename = ""
# We have to make sure the DocType of the package is the one selected
# in preferences and not the one used to save de template
package.docType = G.application.config.docType
if G.application.config.locale.split('_')[0] != 'zh':
package.lang = G.application.config.locale.split('_')[0]
else:
package.lang = G.application.config.locale
package.translatePackage()
package.isChanged = False
self.loaded[package.name] = package
return package
def testExport(self):
# Delete the output dir
outdir = TempDirPath()
G.application = Application()
G.application.loadConfiguration()
G.application.preLaunch()
# Load a package
package = Package.load('testing/testPackage2.elp')
# Do the export
style_dir = G.application.config.stylesDir / package.style
exporter = WebsiteExport(G.application.config,
style_dir,
outdir)
exporter.export(package)
# Check that it all exists now
assert outdir.isdir()
assert (outdir / 'index.html').isfile()
# Check that the style sheets have been copied
for filename in style_dir.files():
assert ((outdir / filename.basename()).exists(),
'Style file "%s" not copied' % (outdir / filename.basename()))
# Check that each node in the package has had a page made
pagenodes = Set([p.node for p in exporter.pages])
othernodes = Set(self._getNodes([], package.root))
assert pagenodes == othernodes
for page in exporter.pages:
self._testPage(page, outdir)
def loadPackage(self, path):
"""
Load a package from disk, add it to the store and return it
"""
package = Package.load(path)
self.loaded[package.name] = package
return package
def do_export(self, inputf, outputf):
if hasattr(self, 'export_' + self.options["export"]):
LOG.debug("Exporting to type %s, in: %s, out: %s, overwrite: %s" \
% (self.options["export"], inputf, outputf, str(self.options["overwrite"])))
if not outputf:
if self.options["export"] in ('website', 'singlepage'):
outputf = inputf.rsplit(".elp")[0]
else:
outputf = inputf + self.extensions[self.options["export"]]
outputfp = Path(outputf)
if outputfp.exists() and not self.options["overwrite"]:
error = _(u'"%s" already exists.\nPlease try again \
with a different filename') % outputf
raise Exception(error.encode(sys.stdout.encoding))
else:
if outputfp.exists() and self.options["overwrite"]:
if outputfp.isdir():
for filen in outputfp.walkfiles():
filen.remove()
outputfp.rmdir()
else:
outputfp.remove()
pkg = Package.load(inputf)
LOG.debug("Package %s loaded" % (inputf))
if not pkg:
error = _(u"Invalid input package")
raise Exception(error.encode(sys.stdout.encoding))
self.styles_dir = self.web_dir.joinpath('style', pkg.style)
LOG.debug("Styles dir: %s" % (self.styles_dir))
getattr(self, 'export_' + self.options["export"])(pkg, outputf)
return outputf
else:
raise Exception(_(u"Export format not implemented")\
.encode(sys.stdout.encoding))
def createPackageFromTemplate(self, templateBase, is_new_package=False):
"""
Creates a new package from Template
"""
log.debug(u"createPackageFromTemplate")
package = Package.load(templateBase, isTemplate=True, is_new_package=is_new_package)
package.set_templateFile(str(templateBase.basename().splitext()[0]))
# Make up an initial unique name
i = 1
name = u"newPackage"
while name in self.loaded:
name = u"newPackage" + unicode(i)
i += 1
# Prevent the package from opening on the last node edited
package.currentNode = package.root
package.name = name
package.filename = ""
# We have to make sure the DocType of the package is the one selected
# in preferences and not the one used to save de template
package.docType = G.application.config.docType
if G.application.config.locale.split('_')[0] != 'zh':
package.lang = G.application.config.locale.split('_')[0]
else:
package.lang = G.application.config.locale
package.translatePackage()
package.isChanged = False
self.loaded[package.name] = package
return package
def _loadPackage(self, client, filename, newLoad=True,
destinationPackage=None):
"""Load the package named 'filename'"""
try:
encoding = sys.getfilesystemencoding()
if encoding is None:
encoding = 'utf-8'
filename2 = toUnicode(filename, encoding)
log.debug("filename and path" + filename2)
# see if the file exists AND is readable by the user
try:
open(filename2, 'rb').close()
except IOError:
filename2 = toUnicode(filename, 'utf-8')
try:
open(filename2, 'rb').close()
except IOError:
client.alert(_(u'File %s does not exist or is not readable.') % filename2)
return None
package = Package.load(filename2, newLoad, destinationPackage)
if package is None:
raise Exception(_("Couldn't load file, please email file to [email protected]"))
except Exception, exc:
if log.getEffectiveLevel() == logging.DEBUG:
client.alert(_(u'Sorry, wrong file format:\n%s') % unicode(exc))
else:
client.alert(_(u'Sorry, wrong file format'))
log.error(u'Error loading package "%s": %s' % (filename2, unicode(exc)))
log.error(u'Traceback:\n%s' % traceback.format_exc())
raise
def createPackageFromTemplate(self, templateBase):
"""
Creates a new package from Template
"""
log.debug(u"createPackageFromTemplate")
package = Package.load(templateBase, isTemplate=True)
package.set_templateFile(str(templateBase.basename().splitext()[0]))
# Make up an initial unique name
i = 1
name = u"newPackage"
while name in self.loaded:
name = u"newPackage" + unicode(i)
i += 1
# Prevent the package from opening on the last node edited
package.currentNode = package.root
package.name = name
package.filename = ""
if G.application.config.locale.split('_')[0] != 'zh':
package.lang = G.application.config.locale.split('_')[0]
else:
package.lang = G.application.config.locale
package.translatePackage()
package.isChanged = False
self.loaded[package.name] = package
return package
def testExport(self):
# Delete the output dir
outdir = TempDirPath()
G.application = Application()
G.application.loadConfiguration()
G.application.preLaunch()
# Load a package
package = Package.load('testing/testPackage2.elp')
# Do the export
style_dir = G.application.config.stylesDir / package.style
exporter = WebsiteExport(G.application.config, style_dir, outdir)
exporter.export(package)
# Check that it all exists now
assert outdir.isdir()
assert (outdir / 'index.html').isfile()
# Check that the style sheets have been copied
for filename in style_dir.files():
assert ((outdir / filename.basename()).exists(),
'Style file "%s" not copied' %
(outdir / filename.basename()))
# Check that each node in the package has had a page made
pagenodes = Set([p.node for p in exporter.pages])
othernodes = Set(self._getNodes([], package.root))
assert pagenodes == othernodes
for page in exporter.pages:
self._testPage(page, outdir)
def doTest(self, ExporterClass):
"""Exports a package with meta data"""
# Load our test package
package = Package.load('testPackage.elp')
# Do the export
outFilename = Path('scormtest.zip')
exporter = ExporterClass(self.app.config,
'../exe/webui/style/default',
outFilename)
exporter.export(package)
# Check that it made a nice zip file
assert outFilename.exists()
# See if the manifest file was created
zipped = ZipFile(outFilename)
filenames = zipped.namelist()
assert 'imsmanifest.xml' in filenames, filenames
self._testManifest(zipped.read('imsmanifest.xml'))
# Test that all the node's html files have been generated
pagenodes = Set([p.node for p in exporter.pages])
othernodes = Set(self._getNodes([], package.root))
assert pagenodes == othernodes
for page in exporter.pages:
self._testPage(page, zipped)
# Clean up
zipped.close()
def loadPackage(self, path):
"""
Load a package from disk, add it to the store and return it
"""
package = Package.load(path)
self.loaded[package.name] = package
return package
def import_xml(self, inputf, outputf):
if not outputf:
outputf = inputf.rsplit(".xml")[0]
xml = open(inputf).read()
pkg = Package.load(outputf, fromxml=xml)
if not pkg:
raise Exception(_(u"Invalid output package '%s'") % outputf)
pkg.save()
return outputf
def import_xml(self, inputf, outputf):
if not outputf:
outputf = inputf.rsplit(".xml")[0]
xml = open(inputf).read()
pkg = Package.load(outputf, fromxml=xml)
if not pkg:
raise Exception(_(u"Invalid output package '%s'") % outputf)
pkg.save()
return outputf
def import_xliff(self, inputf, outputf):
if not outputf:
outputf = inputf.rsplit(".xlf")[0]
pkg = Package.load(outputf)
if not pkg:
raise Exception(_(u"Invalid output package '%s'") % outputf)
importer = XliffImport(pkg, inputf)
importer.parseAndImport(self.options["from-source"])
pkg.save()
return outputf
def import_xliff(self, inputf, outputf):
if not outputf:
outputf = inputf.rsplit(".xlf")[0]
pkg = Package.load(outputf)
if not pkg:
raise Exception(_(u"Invalid output package '%s'") % outputf)
importer = XliffImport(pkg, inputf)
importer.parseAndImport(self.options["from-source"])
pkg.save()
return outputf
def doEditTemplate(self, template):
try:
templateEdit = Package.load(Template(self.config.templatesDir /
template).path,
isTemplate=True)
self.webServer.root.bindNewPackage(templateEdit,
self.client.session)
self.client.sendScript((u'eXe.app.gotoUrl("/%s")' % \
templateEdit.name).encode('utf8'))
except:
self.alert(_(u'Error'), _(u'An unexpected error has occurred'))
def _loadPackage(self, client, filename):
"""Load the package named 'filename'"""
try:
encoding = sys.getfilesystemencoding()
if encoding is None:
encoding = 'utf-8'
filename2 = unicode(filename, encoding)
log.debug("filename and path" + filename2)
package = Package.load(filename2)
if package is None:
filename2 = unicode(filename, 'utf-8')
package = Package.load(filename2)
if package is None:
raise Exception(_("Couldn't load file, please email file to [email protected]"))
except Exception, exc:
if log.getEffectiveLevel() == logging.DEBUG:
client.alert(_(u'Sorry, wrong file format:\n%s') % unicode(exc))
else:
client.alert(_(u'Sorry, wrong file format'))
log.error(u'Error loading package "%s": %s' % (filename2, unicode(exc)))
log.error(u'Traceback:\n%s' % traceback.format_exc())
raise
def __importIdevice(self, filename):
"""
import the idevices which are not existed in current package from another package
"""
newPackage = Package.load(filename)
for idevice in newPackage.idevices:
isExisted = False
for currentIdevice in self.ideviceStore.generic:
if idevice.title == currentIdevice.title:
isExisted = True
break
if not isExisted:
newIdevice = idevice.clone()
self.ideviceStore.addIdevice(newIdevice)
self.ideviceStore.save()
def launch(self):
"""
launches the webbrowser
"""
if self.packagePath:
try:
package = Package.load(self.packagePath)
self.webServer.root.package = package
launchBrowser(self.config, package.name)
except:
self.webServer.root.packagePath = None
launchBrowser(self.config, "")
else:
launchBrowser(self.config, "")
def _loadPackage(self, client, filename):
"""Load the package named 'filename'"""
try:
encoding = sys.getfilesystemencoding()
if encoding is None:
encoding = 'ascii'
filename = unicode(filename, encoding)
log.debug("filename and path" + filename)
package = Package.load(filename)
except Exception, exc:
if log.getEffectiveLevel() == logging.DEBUG:
client.alert(_(u'Sorry, wrong file format:\n%s') % unicode(exc))
else:
client.alert(_(u'Sorry, wrong file format'))
log.error(_(u'Error loading package "%s": %s') % \
(filename, unicode(exc)))
log.error((u'Traceback:\n%s' % traceback.format_exc()))
raise
def __importIdevice(self, filename):
"""
import the idevices which are not existed in current package from another package
"""
try:
newPackage = Package.load(filename)
except:
self.message = _("Sorry, wrong file format.")
return
if newPackage:
newIdevice = newPackage.idevices[-1].clone()
for currentIdevice in self.ideviceStore.generic:
if newIdevice.title == currentIdevice.title:
newIdevice.title += "1"
break
self.ideviceStore.addIdevice(newIdevice)
self.ideviceStore.save()
else:
self.message = _("Sorry, wrong file format.")
def testSaveAndLoad(self):
packageStore = PackageStore()
package = packageStore.createPackage()
# Check that it has been given a default name
self.assertEquals(package.name, "newPackage")
package.author = "UoA"
package.description = "Nice test package"
Config._getConfigPathOptions = lambda s: ['exe.conf']
config = Config()
filePath = config.dataDir / 'package1.elp'
package.save(filePath)
package1 = Package.load(filePath)
self.assert_(package1)
self.assertEquals(package1.author, "UoA")
self.assertEquals(package1.description, "Nice test package")
# Package name should have been set when it was saved
self.assertEquals(package.name, "package1")
self.assertEquals(package1.name, "package1")
def doTest(self, ExporterClass):
"""Exports a package with meta data"""
package = Package.load('testPackage.elp')
outFilename = Path('scormtest.zip')
exporter = ExporterClass(self.app.config,
'../exe/webui/style/default',
outFilename)
exporter.export(package)
assert outFilename.exists()
zipped = ZipFile(outFilename)
filenames = zipped.namelist()
assert 'imsmanifest.xml' in filenames, filenames
self._testManifest(zipped.read('imsmanifest.xml'))
pagenodes = Set([p.node for p in exporter.pages])
othernodes = Set(self._getNodes([], package.root))
assert pagenodes == othernodes
for page in exporter.pages:
self._testPage(page, zipped)
zipped.close()
def _testSaveAndLoad(self):
packageStore = PackageStore()
package = packageStore.createPackage()
# Check that it has been given a default name
self.assertEquals(package.name, "newPackage")
package.author = "UoA"
package.description = "Nice test package"
Config._getConfigPathOptions = lambda s: ["exe.conf"]
config = Config()
filePath = config.dataDir / "package1.elp"
package.save(filePath)
package1 = Package.load(filePath)
self.assert_(package1)
self.assertEquals(package1.author, "UoA")
self.assertEquals(package1.description, "Nice test package")
# Package name should have been set when it was saved
self.assertEquals(package.name, "package1")
self.assertEquals(package1.name, "package1")
def testExport(self):
outdir = TempDirPath()
package = Package.load('testPackage.elp')
exporter = WebsiteExport('../exe/webui/style/default',
outdir,
'../exe/webui/images',
'../exe/webui/scripts',
'../exe/webui/templates')
exporter.export(package)
assert outdir.isdir()
assert (outdir / 'index.html').isfile()
for filename in Path('../exe/webui/style/default').files():
assert ((outdir / filename.basename()).exists(),
'Style file "%s" not copied' % (outdir / filename.basename()))
pagenodes = Set([p.node for p in exporter.pages])
othernodes = Set(self._getNodes([], package.root))
assert pagenodes == othernodes
for page in exporter.pages:
self._testPage(page, outdir)
def __importIdevice(self, filename):
"""
import the idevices which are not existed in current package from another package
"""
try:
newPackage = Package.load(filename)
except:
self.message = _("Sorry, wrong file format.")
return
if newPackage:
newIdevice = newPackage.idevices[-1].clone()
for currentIdevice in self.ideviceStore.generic:
if newIdevice.title == currentIdevice.title:
newIdevice.title += "1"
break
self.ideviceStore.addIdevice(newIdevice)
self.ideviceStore.save()
else:
self.message = _("Sorry, wrong file format.")
def testSaveAndLoad(self):
packageStore = PackageStore()
package = packageStore.createPackage()
# Check that it has been given a default name
self.assertEquals(package.name, "newPackage")
package.author = "UoA"
package.description = "Nice test package"
Config._getConfigPathOptions = lambda s: ['exe.conf']
config = Config()
SuperTestCase.update_config_parser(config.configParser)
config.loadSettings()
filePath = config.dataDir/'package1.elp'
package.save(filePath)
package1 = Package.load(filePath)
self.assert_(package1)
self.assertEquals(package1.author, "UoA")
self.assertEquals(package1.description, "Nice test package")
# Package name should have been set when it was saved
self.assertEquals(package.name, "package1")
self.assertEquals(package1.name, "package1")
def _loadPackage(self,
client,
filename,
newLoad=True,
destinationPackage=None):
"""Load the package named 'filename'"""
try:
encoding = sys.getfilesystemencoding()
if encoding is None:
encoding = 'utf-8'
filename2 = toUnicode(filename, encoding)
log.debug("filename and path" + filename2)
# see if the file exists AND is readable by the user
try:
open(filename2, 'rb').close()
except IOError:
filename2 = toUnicode(filename, 'utf-8')
try:
open(filename2, 'rb').close()
except IOError:
client.alert(
_(u'File %s does not exist or is not readable.') %
filename2)
return None
package = Package.load(filename2, newLoad, destinationPackage)
if package is None:
raise Exception(
_("Couldn't load file, please email file to [email protected]"
))
except Exception, exc:
if log.getEffectiveLevel() == logging.DEBUG:
client.alert(
_(u'Sorry, wrong file format:\n%s') % unicode(exc))
else:
client.alert(_(u'Sorry, wrong file format'))
log.error(u'Error loading package "%s": %s' %
(filename2, unicode(exc)))
log.error(u'Traceback:\n%s' % traceback.format_exc())
raise
def render_POST(self, request):
#check the parameters
required_headers = ['ldshake_frame_origin','name','sectoken']
for r_h in required_headers:
if r_h not in request.args:
return 'error'
#get an id and increment the counter
self.id_count_lock.acquire()
id = self.id_count;
self.id_count += 1
self.id_count_lock.release()
package_name = request.args['sectoken'][0]
if 'document' not in request.args:
package = Package(package_name)
else:
fullpath = '/var/local/exelearning/' + package_name + '_' + str(random.randrange(1,999999)) + '.elp'
try:
elp_file = open(fullpath, "wb")
elp_file.write(request.args['document'][0])
elp_file.close()
package = Package.load(fullpath, True, None)
package.set_name(package_name)
except:
return 'error'
self.putChild(str(id), LdShakeDocument({
'name': request.args['name'][0],
'sectoken': request.args['sectoken'][0],
'ldshake_frame_origin': request.args['ldshake_frame_origin'][0]
}, self, package, self.webserver))
#return the resource URL
return request.prePathURL() + str(id) + '/'
file_w.write(u'# Generated on %s\n' % str(datetime.now()))
file_w.write(u'\ntemplates = {\n')
# Go through all templates (only take into account .elt files)
package_index = 0
for file_name in [
f for f in os.listdir(application.config.templatesDir)
if os.path.splitext(f)[1] == '.elt'
]:
print(u'Extracting messages from %s...' %
(application.config.templatesDir / file_name))
# Load the template as a package
template = Template(application.config.templatesDir / file_name)
package = Package.load(application.config.templatesDir / file_name,
newLoad=True)
# Write template header comment and definition start
file_w.write(put_tabs(1))
file_w.write(u'# Template: %s\n' % file_name)
file_w.write(put_tabs(1))
file_w.write(u'\'template_%i\': {\n' % package_index)
# Template name
file_w.write(put_tabs(2))
file_w.write(u'\'template_name\': _(u\'%s\'),\n' %
normalize_text(template.name))
# Template author
if template.author != u'':
file_w.write(put_tabs(2))
file_w.write(u'\'template_author\': _(u\'%s\'),\n' %
]
# Open output file and write generation date
file_w = open(application.config.templatesDir / u'strings.py', 'w');
file_w.write(u'# Generated on %s\n' % str(datetime.now()))
file_w.write(u'\ntemplates = {\n')
# Go through all templates (only take into account .elt files)
package_index = 0
for file_name in [f for f in os.listdir(application.config.templatesDir) if os.path.splitext(f)[1] == '.elt']:
print(u'Extracting messages from %s...' % (application.config.templatesDir / file_name))
# Load the template as a package
template = Template(application.config.templatesDir / file_name)
package = Package.load(application.config.templatesDir / file_name, newLoad=True);
# Write template header comment and definition start
file_w.write(put_tabs(1))
file_w.write(u'# Template: %s\n' % file_name)
file_w.write(put_tabs(1))
file_w.write(u'\'template_%i\': {\n' % package_index)
# Template name
file_w.write(put_tabs(2))
file_w.write(u'\'template_name\': _(u\'%s\'),\n' % normalize_text(template.name))
# Template author
if template.author != u'':
file_w.write(put_tabs(2))
file_w.write(u'\'template_author\': _(u\'%s\'),\n' % normalize_text(template.author))
def testUstadMobileExport(self):
# Load a package
filePath = self.inFilePath
package = Package.load(filePath)
self.assertIsNotNone(package, "Failed to load package")
#test the tincan.xml generation
desc_text = "Description Test"
package.set_description(desc_text)
self.assertEqual(desc_text, package.get_tincan_description(),
"Description set and picked up")
#test description will be title when description is blank
package.set_description("")
self.assertEqual(package.get_tincan_title(),
package.get_tincan_description(),
"Description blank, tincan desc = title")
styles_dir = G.application.config.stylesDir / package.style
xmlExport = XMLExport(G.application.config, styles_dir,
self.epubOutPath)
xmlExport.export(package)
self.extract_dir = TempDirPath()
zip_file = ZipFile(self.epubOutPath)
zip_file.extractall(self.extract_dir)
outdir = self.extract_dir/"EPUB"
#test that we can force it to have a title and identifier
missing_metadata_dict = {"title" : "", "identifier" : ""}
cover = xmlExport.make_cover_page(package)
self.assertIsNotNone(cover, "Can create cover for package")
publication= xmlExport.make_publication_epub3(outdir, package, cover)
self.assertIsNotNone(publication, "Can create publication object")
fixed_metadata = publication.check_metadata_for_epub(
missing_metadata_dict, package)
self.assertTrue(len(fixed_metadata['title']) > 0,
"Title Added")
self.assertEqual(fixed_metadata['identifier'],
package.dublinCore.identifier,
"Identifier added from dublin core")
#check that the modification time on our resource files
#are as per original so they can be easily cached
xml_copy_list = xmlExport.make_xml_copy_list(package, outdir)
TestUtils.check_copy_list_mod_time(xml_copy_list,self)
mainFolder = Path(self.extract_dir/"EPUB")
assert mainFolder.exists()
exeTocPath = Path(mainFolder / "exetoc.xml")
#check the tincan.xml
tincan_etree_doc = ElementTree.parse(
self.extract_dir/"tincan.xml")
namespaces = {"tincan" :
"http://projecttincan.com/tincan.xsd"}
tincan_etree = tincan_etree_doc.getroot()
launch_el_arr = tincan_etree.findall(
"tincan:activities/tincan:activity/tincan:launch",
namespaces)
self.assertEqual(len(launch_el_arr), 1,
"1 activity with launch")
self.assertEqual(
tincan_etree.find(
"tincan:activities/tincan:activity[0]/tincan:name",
namespaces).text,
package.get_tincan_title())
self.assertEqual(
tincan_etree.find(
"tincan:activities/tincan:activity[0]/tincan:description",
namespaces).text,
package.get_tincan_description(),
"Description serialized matchese tincan desc")
str = exeTocPath.open().read()
from xml.dom.minidom import parse, parseString
dom = parseString(str)
self.assertIsNotNone(dom, "Did not parse exetoc.xml it seems")
self.assertEqual(dom.documentElement.tagName, "exebase", "exebase is not the tag")
audioFormatList = dom.documentElement.getAttribute("audioformats")
videoFormatList = dom.documentElement.getAttribute("videoformats")
resolutionList = dom.documentElement.getAttribute("resolutions")
pageNodeList = dom.getElementsByTagName("page")
for page in pageNodeList:
href = page.getAttribute("href")
pagePath = Path(mainFolder / href)
self.assertTrue(pagePath.exists(), "FAILED: " + href + " does not exist")
pageString = pagePath.open().read()
pageDOM = parseString(pageString)
self.assertIsNotNone(pageDOM, "Failed to read " + href + " into DOM")
ideviceListFromToc = page.getElementsByTagName("idevice")
for ideviceEl in ideviceListFromToc:
# look for the idevice in the DOM list of the page
foundDeviceInPage = False
foundIdeviceInPageEl = None
ideviceIdFromToc = ideviceEl.getAttribute("id")
ideviceListFromPage = pageDOM.getElementsByTagName("idevice")
for ideviceElFromPage in ideviceListFromPage:
if ideviceElFromPage.getAttribute("id") == ideviceIdFromToc:
foundDeviceInPage = True
foundIdeviceInPageEl = ideviceElFromPage
self.assertTrue(foundDeviceInPage, "idevice id " \
+ ideviceIdFromToc + " was not in page " + href)
# procedure to check media slide
if foundIdeviceInPageEl.getAttribute("type") == "mediaslide":
#self.doCheckMediaSlide(foundIdeviceInPageEl, href, mainFolder, package, dom.documentElement)
pass
pass
inputf = args[0]
try:
outputf = args[1]
except IndexError:
outputf = None
if len(args) > 2:
parser.error(_(u'Bad number of arguments supplied').encode(sys.stdout.encoding))
tempdir = TempDirPath()
if options.set_options:
try:
path = Path(inputf)
path.copy(tempdir)
inputf = tempdir / path.basename()
pkg = Package.load(inputf)
if not pkg:
error = _(u"Invalid input package")
raise Exception(error.encode(sys.stdout.encoding))
set_options = options.set_options.split(',')
for set_option in set_options:
name, value = set_option.split('=')
names = name.split('.')
obj = pkg
for name in names[:-1]:
obj = getattr(obj, name)
name = names[-1]
prop_type = type(getattr(obj, name))
print("Printing name and value..")
print(name)
def testExport(self):
# Delete the output dir
outdir = TempDirPath()
G.application = Application()
G.application.loadConfiguration()
G.application.preLaunch()
# Load a package
package = Package.load('testing/testPackage2.elp')
# Do the export
style_dir = G.application.config.stylesDir / package.style
exporter = WebsiteExport(G.application.config,
style_dir,
outdir)
exporter.export(package)
# Check that it all exists now
assert outdir.isdir()
assert (outdir / 'index.html').isfile()
# Check that the style sheets have been copied
for filename in style_dir.files():
#Skip the styles config.xml - that should not be included
if filename.basename() == "config.xml":
continue
assert ((outdir / filename.basename()).exists(),
'Style file "%s" not copied' % (outdir / filename.basename()))
#check the modification time is correct
f_dst = Path(outdir/filename.basename())
f_src = Path(filename)
self.assertTrue(
TestUtils.mod_time_diff(f_dst, f_src) < 0.1,
"Modification time in style dir preserved")
for res_file in package.resourceDir.files():
dst_file = Path(outdir/ res_file.basename())
self.assertTrue(dst_file.isfile())
self.assertTrue(
TestUtils.mod_time_diff(res_file, dst_file) < 0.1,
"Resource file %s has same mod time as origin" \
% res_file.basename())
#test that everything that was copied hahs the right mod time
copy_list = package.make_system_copy_list(style_dir,
G.application.config.webDir/"scripts" ,
G.application.config.webDir/"templates",
G.application.config.webDir/"images",
G.application.config.webDir/"css",
outdir)
TestUtils.check_copy_list_mod_time(copy_list, self)
# Check that each node in the package has had a page made
pagenodes = Set([p.node for p in exporter.pages])
othernodes = Set(self._getNodes([], package.root))
assert pagenodes == othernodes
for page in exporter.pages:
self._testPage(page, outdir)
