def __getPublishedUrl(self, response, draft):
""" To get the published url
@param response: Response returned by server
@type response: String
@param draft: type of the content
@param draft: Boolean
@rtype: String
@return: url where the content is published
"""
publishedUrl = None
try:
response = unicode(str(response), "utf-8")
entry = atom.EntryFromString(response)
if entry != None:
altLink = entry.GetAlternateLink()
if altLink is None:
# no alternate link so just get the first link
for link in entry.link:
if link.rel == None:
altLink = link
break
if not draft and altLink is not None:
publishedUrl = altLink.href
except Exception, e:
self.__output.write("Failed parsing response: %s\n" % str(e))
def parseEntry(entry):
""" to get the feed from the given entry
@param entry: Entry
@type entry: String
@rtype: ElementTree._Element, or xml_wrapper.ElementWrapper
@return: atom entry
"""
return atom.EntryFromString(entry)
def testConvertToAndFromString(self):
entry = atom.Entry()
entry.author.append(atom.Author(name=atom.Name(text='js')))
entry.title = atom.Title(text='my test entry')
self.assert_(entry.author[0].name.text == 'js')
self.assert_(entry.title.text == 'my test entry')
new_entry = atom.EntryFromString(entry.ToString())
self.assert_(new_entry.author[0].name.text == 'js')
self.assert_(new_entry.title.text == 'my test entry')
def testEntryCorrectlyConvertsActualData(self):
entry = atom.EntryFromString(test_data.XML_ENTRY_1)
self.assert_(entry.category[0].scheme ==
'http://base.google.com/categories/itemtypes')
self.assert_(entry.category[0].term == 'products')
self.assert_(
entry.id.text == ' http://www.google.com/test/id/url ')
self.assert_(entry.title.text == 'Testing 2000 series laptop')
self.assert_(entry.title.type == 'text')
self.assert_(entry.content.type == 'xhtml')
def testMemberStringEncoding(self):
atom_entry = atom.EntryFromString(self.test_xml)
#self.assertEqual(atom_entry.title.type.encode('utf-8'),
# u'\u03B1\u03BB\u03C6\u03B1'.encode('utf-8'))
#self.assertEqual(atom_entry.title.text.encode('utf-8'),
# u'\u03B1\u03BB\u03C6\u03B1'.encode('utf-8'))
# Setting object members to unicode strings is supported even if
# MEMBER_STRING_ENCODING is set 'utf-8' (should it be?)
atom_entry.title.type = '\\u03B1\\u03BB\\u03C6\\u03B1'
xml = atom_entry.ToString()
self.assertTrue('\\u03B1\\u03BB\\u03C6\\u03B1'.encode('utf-8') in xml)
# Make sure that we can use plain text when MEMBER_STRING_ENCODING is utf8
atom_entry.title.type = "plain text"
atom_entry.title.text = "more text"
xml = atom_entry.ToString()
self.assertTrue("plain text" in xml)
self.assertTrue("more text" in xml)
# Test something else than utf-8
atom.MEMBER_STRING_ENCODING = 'iso8859_7'
atom_entry = atom.EntryFromString(self.test_xml)
self.assertTrue(atom_entry.title.type ==
'\\u03B1\\u03BB\\u03C6\\u03B1'.encode('iso8859_7'))
self.assertTrue(atom_entry.title.text ==
'\\u03B1\\u03BB\\u03C6\\u03B1'.encode('iso8859_7'))
# Test using unicode strings directly for object members
atom.MEMBER_STRING_ENCODING = str
atom_entry = atom.EntryFromString(self.test_xml)
self.assertTrue(
atom_entry.title.type == '\\u03B1\\u03BB\\u03C6\\u03B1')
self.assertTrue(
atom_entry.title.text == '\\u03B1\\u03BB\\u03C6\\u03B1')
# Make sure that we can use plain text when MEMBER_STRING_ENCODING is
# unicode
atom_entry.title.type = "plain text"
atom_entry.title.text = "more text"
xml = atom_entry.ToString()
self.assertTrue("plain text" in xml)
self.assertTrue("more text" in xml)
def __post(self, author, title, summary, content, category, draft,
entryXml):
""" to post the content to the server
@param author: Author name
@type author: String
@param title: Title of the content
@type title: String
@param summary: Summary of the content
@type summary: String
@param content: Content
@type content: String
@param draft: Type of the document:
@type draft: boolean
@param entryXml: extra entry
@type entryXml: String
@rtype: (Atom Entry, String)
@return: entry, httpResponse
"""
# create/update the atom entry
if entryXml == None:
entry = atom.Entry()
entryUri = self.entryUri
else:
entry = atom.EntryFromString(entryXml)
entryUri = entry.GetEditLink().href
entry.author = [atom.Author(text=author)]
entry.title = atom.Title(text=title)
entry.summary = atom.Summary(text=summary)
entry.content = atom.Content(content_type="html",
text=unicode(content, "utf-8"))
if category != "":
entry.category = atom.Category(term=category)
if draft:
entry.control = atom.Control(draft=atom.Draft(text="yes"))
else:
entry.control = atom.Control(draft=atom.Draft(text="no"))
# setup the http headers for authorisation
extraHeaders = {"Slug": title}
extraHeaders.update(self.authHeaders)
# use POST or PUT depending on whether it is a new entry or an update
if entryXml != None:
publishFunc = self.atomService.Put
else:
publishFunc = self.atomService.Post
self.__checkNoProxy(entryUri)
httpResponse = publishFunc(data=entry,
uri=entryUri,
extra_headers=extraHeaders)
self.__resetProxy()
return entry, httpResponse
def __getPublishedCategory(self, response):
""" To get the published category
@param response: Response returned by server
@type response: String
@rtype: String
@return: category in which the content is published
"""
publishedCategory = "Uncategorized"
try:
response = unicode(str(response), "utf-8")
entry = atom.EntryFromString(response)
if entry != None:
publishedCategory = entry.category[0].term
except Exception, e:
self.__output.write("Failed parsing response: %s\n" % str(e))
def __processMedia(self, iceAtomPub, content):
""" process the Media url found in the content to be published
e.g. all files in _files folder
@param iceAtomPub: Current atom feed
@type iceAtomPub: IceAtomPub
@param content: content to be published
@type content: String
@rtype: String
@return: content
"""
# get media and upload them
_, baseName, _ = self.__fs.splitPathFileExt(self.__filename)
if iceAtomPub.supportsMedia() and callable(self.__getMedia):
mediaList = self.__getMedia()
print "mediaList='%s'" % str(mediaList)
for mediaEntry in mediaList:
try:
mediaData = self.__getMedia(mediaEntry)
_, mediaTitle, ext = self.__fs.splitPathFileExt(mediaEntry)
## HACK just use image/(ext) instead of proper mimetype so wordpress accepts it
#mimeType = "image/" + ext[1:]
if self.iceContext.MimeTypes.has_key(ext):
mimeType = self.iceContext.MimeTypes[ext]
if mimeType == "application/pdf":
#for wordpress, the pdf has to pretend to be the image.
mimeType = "image/pdf"
#print "mimetype:",mimeType
#print "postMedia(mediaTitle='%s', mediaData=%s(len), mimeType='%s')" % (mediaTitle, len(mediaData), mimeType)
mediaResponse = iceAtomPub.postMedia(
mediaTitle, mediaData, mimeType)
mediaEntryXml = atom.EntryFromString(mediaResponse)
src = "%s_files/%s" % (baseName, mediaEntry)
#print " src='%s'" % src
if content.find(src) == -1:
# most likely not an image
src = mediaEntry
print "did not find content!"
newSrc = mediaEntryXml.content.src
if newSrc is None or newSrc == "":
raise Exception("Unknown content @src=None)")
content = content.replace(src, newSrc)
print "Uploaded %s to %s" % (src, newSrc)
except Exception, e:
self.__output.write("Failed to upload image: %s (%s)\n" %
(mediaEntry, e))
def setUp(self):
self.entry = atom.EntryFromString(test_data.XML_ENTRY_1)
def testAppControl(self):
entry = atom.EntryFromString(test_data.TEST_BASE_ENTRY)
self.assertEquals(entry.control.draft.text, 'yes')
self.assertEquals(len(entry.control.extension_elements), 1)
self.assertEquals(entry.control.extension_elements[0].tag,
'disapproved')
def testMemberStringEncoding(self):
atom_entry = atom.EntryFromString(self.test_xml)
self.assert_(atom_entry.title.type ==
u'\u03B1\u03BB\u03C6\u03B1'.encode('utf-8'))
self.assert_(atom_entry.title.text ==
u'\u03B1\u03BB\u03C6\u03B1'.encode('utf-8'))
def entry_from_string_wrapper(response):
self.assert_(response.getheader('content-type') is not None)
self.assert_(response.getheader('gdata-version') is not None)
return atom.EntryFromString(response.read())
def swordDeposit(self):
d = { "authtype" : "none",
"username" : self["username"],
"password" : "",
"argPath" : self.path,
"collections" : None
}
self.isDocContentView = False
if self.isPackage:
path = "%stoc.rdf" % self.packagePath
item = self.rep.getItemForUri(path)
self.title = d["title"] = self.manifestTitle
else:
item = self.rep.getItemForUri(self.path)
basePath, _ = self.iceContext.fs.splitExt(item.relPath)
path = "%s.rdf" % basePath
item = self.rep.getItemForUri(path)
d["title"] = item.getMeta("title", item.name)
if d["title"] is None:
d["title"] = "Untitled"
self.title = 'Deposit "' + d["title"] + '"'
postback = self.formData.has_key("postback")
if postback:
if self.formData.has_key("url"):
d["url"] = self.formData.value("url").strip()
if self.formData.has_key("authtype"):
d["authtype"] = self.formData.value("authtype").strip().lower()
if self.formData.has_key("username"):
d["username"] = self.formData.value("username").strip()
if self.formData.has_key("password"):
d["password"] = self.formData.value("password").strip()
if self.formData.has_key("title"):
d["title"] = self.formData.value("title").strip()
if self.formData.has_key("collection"):
d["collection"] = self.formData.value("collection").strip()
try:
IceAtomPub = self.iceContext.getPluginClass("ice.atompub")
if IceAtomPub is None:
raise Exception("Failed to get Atom Publishing plugin!")
atomPub = IceAtomPub(d["url"], d["authtype"], d["username"], d["password"])
d["collections"] = []
if atomPub.hasServiceDocument:
for ws in atomPub.service.workspaces:
for c in ws.collections:
formatNamespaceElems = c.getSwordElementList("formatNamespace")
c.supported = False
for formatNamespaceElem in formatNamespaceElems:
if formatNamespaceElem.text.strip() == "IceORE":
c.supported = True
break
print c
d["collections"].append(c)
else:
raise Exception, "No service document found."
if self.formData.has_key("doDeposit"):
d["docBody"] = self.body
url = d.get("collection", "")
print "Deposit to:", url
if url == "":
d["status"] = "Please select a collection"
else:
if self.isPackage:
resMap = self.serve(item, ServerRequestData(path), self.session)[0]
else:
resMap = item.getRendition(".rdf")
resMap = resMap.replace("?exportVersion=1", "?exportVersion=noContextLink")
_, filename, _ = self.iceContext.fs.splitPathFileExt(path)
swordHeaders = {"Content-Disposition": "filename=%s.rdf" % filename,
"X-Format-Namespace": "IceORE"}
atomPub = IceAtomPub(url, d["authtype"], d["username"], d["password"])
response = atomPub.postMedia(d["title"], resMap, "text/xml", swordHeaders, url)
if response is not None:
d["success"] = True
d["response"] = self.iceContext.xmlEscape(str(response))
# TODO eprints returns links in the atom response
# that don't resolve so they're unusable
#print "response=[%s]\n" % response
atomXml = atom.EntryFromString(response)
d["contentLink"] = atomXml.content.src
print " * content link: %s" % d["contentLink"]
except Exception, details:
details = self.iceContext.xmlEscape(str(details))
print "* SWORD Deposit failed: %s" % details
print self.iceContext.formattedTraceback()
d["error"] = "Failed to deposit. Ensure all fields are correctly filled in."
d["response"] = details
def entry_from_string_wrapper(response):
return atom.EntryFromString(response.read())
