def notifyHealers(txn, errorDetails, pid, tid, extraData):
m = Document()
notification = m.appendChild(m.createElement('message'))
notification.setAttribute('kind', 'fault notification')
faultNode = m.createElement('faulty')
for k,v in tid:
faultNode.setAttribute(str(k), str(v))
error = m.createElement('errors')
for k,v in errorDetails:
error.setAttribute(str(k), str(v))
notification.appendChild(faultNode)
notification.appendChild(error)
'''We are sending the notification... But to whom??'''
healers = txn.runQuery('SELECT * FROM healing_group')
monitors = txn.runQuery('SELECT * FROM monitoring_group')
writer = BundleWriter('dtnhealing:')
for p in healers:
writer.write(m.toxml())
for p in monitors:
writer.write(m.toxml())
monitoringPlans[pid][tid].stop()
def _build_request_xml(self, method_name, **kwargs):
"""
Builds the XML for a 'initial' transaction
"""
doc = Document()
req = self._create_element(doc, doc, "Request")
# Authentication
auth = self._create_element(doc, req, "Authentication")
self._create_element(doc, auth, "client", self._client)
self._create_element(doc, auth, "password", self._password)
# Transaction
txn = self._create_element(doc, req, "Transaction")
# CardTxn
if "card_number" in kwargs:
card_txn = self._create_element(doc, txn, "CardTxn")
self._create_element(doc, card_txn, "method", method_name)
card = self._create_element(doc, card_txn, "Card")
self._create_element(doc, card, "pan", kwargs["card_number"])
self._create_element(doc, card, "expirydate", kwargs["expiry_date"])
if "start_date" in kwargs:
self._create_element(doc, card, "startdate", kwargs["start_date"])
if "issue_number" in kwargs:
self._create_element(doc, card, "issuenumber", kwargs["issue_number"])
if "auth_code" in kwargs:
self._create_element(doc, card, "authcode", kwargs["auth_code"])
if self._cv2avs:
self._add_cv2avs_elements(doc, card, kwargs)
# HistoricTxn
if "txn_reference" in kwargs:
historic_txn = self._create_element(doc, txn, "HistoricTxn")
self._create_element(doc, historic_txn, "reference", kwargs["txn_reference"])
self._create_element(doc, historic_txn, "method", method_name)
if "auth_code" in kwargs:
self._create_element(doc, historic_txn, "authcode", kwargs["auth_code"])
# TxnDetails
if "amount" in kwargs:
txn_details = self._create_element(doc, txn, "TxnDetails")
if "merchant_reference" in kwargs:
self._create_element(doc, txn_details, "merchantreference", kwargs["merchant_reference"])
self._create_element(doc, txn_details, "amount", str(kwargs["amount"]), {"currency": kwargs["currency"]})
# Save XML for later retrieval
self._last_request_xml = doc.toxml()
return self.do_request(doc.toxml())
def _build_request_xml(self, method_name, **kwargs):
"""
Builds the XML for a 'initial' transaction
"""
doc = Document()
req = self._create_element(doc, doc, 'Request')
# Authentication
auth = self._create_element(doc, req, 'Authentication')
self._create_element(doc, auth, 'client', self._client)
self._create_element(doc, auth, 'password', self._password)
# Transaction
txn = self._create_element(doc, req, 'Transaction')
# CardTxn
if 'card_number' in kwargs:
card_txn = self._create_element(doc, txn, 'CardTxn')
self._create_element(doc, card_txn, 'method', method_name)
card = self._create_element(doc, card_txn, 'Card')
self._create_element(doc, card, 'pan', kwargs['card_number'])
self._create_element(doc, card, 'expirydate', kwargs['expiry_date'])
if 'start_date' in kwargs:
self._create_element(doc, card, 'startdate', kwargs['start_date'])
if 'issue_number' in kwargs:
self._create_element(doc, card, 'issuenumber', kwargs['issue_number'])
if 'auth_code' in kwargs:
self._create_element(doc, card, 'authcode', kwargs['auth_code'])
if self._cv2avs:
self._add_cv2avs_elements(doc, card, kwargs)
# HistoricTxn
if 'txn_reference' in kwargs:
historic_txn = self._create_element(doc, txn, 'HistoricTxn')
self._create_element(doc, historic_txn, 'reference', kwargs['txn_reference'])
self._create_element(doc, historic_txn, 'method', method_name)
if 'auth_code' in kwargs:
self._create_element(doc, historic_txn, 'authcode', kwargs['auth_code'])
# TxnDetails
if 'amount' in kwargs:
txn_details = self._create_element(doc, txn, 'TxnDetails')
if 'merchant_reference' in kwargs:
self._create_element(doc, txn_details, 'merchantreference', kwargs['merchant_reference'])
self._create_element(doc, txn_details, 'amount', str(kwargs['amount']), {'currency': kwargs['currency']})
# Save XML for later retrieval
self._last_request_xml = doc.toxml()
return self.do_request(doc.toxml())
def generate_ticket_body(subject_text,
body_text,
requester_email_text,
use_configured_assignee=True):
doc = Document()
# Create the outer ticket element
ticket = doc.createElement("ticket")
doc.appendChild(ticket)
# Create the other data
subject = doc.createElement('subject')
subject.appendChild(doc.createTextNode(subject_text))
ticket.appendChild(subject)
requester = doc.createElement('requester-email')
requester.appendChild(doc.createTextNode(requester_email_text))
ticket.appendChild(requester)
requester = doc.createElement('group-id')
requester.appendChild(doc.createTextNode('86020'))
ticket.appendChild(requester)
if (use_configured_assignee
and getattr(settings, "ZENDESK_ASSIGN_TO_USER_ID", None)):
value = getattr(settings, "ZENDESK_ASSIGN_TO_USER_ID")
assignee = doc.createElement('assignee-id')
assignee.appendChild(doc.createTextNode(unicode(value)))
ticket.appendChild(assignee)
description = doc.createElement('description')
description.appendChild(doc.createTextNode(body_text))
ticket.appendChild(description)
return doc.toxml()
def getDocument(dataset):
gzSupport.addMessage(dataset)
desc = arcpy.Describe(dataset)
xmlDoc = Document()
root = xmlDoc.createElement('table')
xmlDoc.appendChild(root)
root.setAttribute("xmlns",'http://gizinta.com')
if desc.baseName.find('.') > -1:
baseName = desc.baseName[desc.baseName.rfind('.')+1:]
else:
baseName = desc.baseName
source = xmlDoc.createElement("data")
source.setAttribute("name",baseName)
root.appendChild(source)
fields = getFields(dataset)
i=0
try:
for field in fields:
fNode = xmlDoc.createElement("row")
fNode.setAttribute("id",str(i))
source.appendChild(fNode)
addFieldElement(xmlDoc,fNode,"FieldName",field.name)
addFieldElement(xmlDoc,fNode,"SourceField","")
addFieldElement(xmlDoc,fNode,"SourceQA","Required") # need to get these values from template project.
addFieldElement(xmlDoc,fNode,"TargetQA","Required")
addFieldElement(xmlDoc,fNode,"SourceMethod","Copy")
addFieldElement(xmlDoc,fNode,"FieldType",field.type)
addFieldElement(xmlDoc,fNode,"FieldLength",str(field.length))
i += 1
xmlStr = xmlDoc.toxml()
except:
gzSupport.showTraceback()
xmlStr =""
return xmlStr
def testTaxes7(self):
doc = Document()
parent_node = doc.createElement('parent_node')
doc.appendChild(parent_node)
data = {
'default-tax-table': {
'tax-rules': [
{
'shipping-taxed': True,
'rate': 0.175,
'tax-area': {
'postal-area': [
{'country-code': 'DE'},
{'country-code': 'ES'},
{'country-code': 'GB'},
],
},
},
]
},
}
self.gc._taxes(doc, parent_node, data)
xml1 = "<parent_node><tax-tables>\
<default-tax-table><tax-rules><default-tax-rule>\
<shipping-taxed>true</shipping-taxed><rate>0.175</rate>\
<tax-areas><postal-area><country-code>DE</country-code>\
</postal-area><postal-area><country-code>ES</country-code>\
</postal-area><postal-area><country-code>GB</country-code>\
</postal-area></tax-areas></default-tax-rule></tax-rules>\
</default-tax-table></tax-tables></parent_node>"
doc_good = parseString(xml1)
self.assertEquals(doc.toxml(), doc_good.toxml())
def createGeneralUnknownResponse(self, message):
doc = Document()
root_response = doc.createElement('Response')
root_response.setAttribute("creationSuccessful", str(False))
root_response.setAttribute("reason", message)
doc.appendChild(root_response)
return doc.toxml(encoding='utf-8')
def encode(self):
# Create the XML document
doc = Document()
signed_cred = doc.createElement("signed-credential")
# Declare namespaces
# Note that credential/policy.xsd are really the PG schemas
# in a PL namespace.
# Note that delegation of credentials between the 2 only really works
# cause those schemas are identical.
# Also note these PG schemas talk about PG tickets and CM policies.
signed_cred.setAttribute("xmlns:xsi", "http://www.w3.org/2001/XMLSchema-instance")
signed_cred.setAttribute("xsi:noNamespaceSchemaLocation", "http://www.geni.net/resources/credential/2/credential.xsd")
signed_cred.setAttribute("xsi:schemaLocation", "http://www.planet-lab.org/resources/sfa/ext/policy/1 http://www.planet-lab.org/resources/sfa/ext/policy/1/policy.xsd")
# PG says for those last 2:
# signed_cred.setAttribute("xsi:noNamespaceSchemaLocation", "http://www.protogeni.net/resources/credential/credential.xsd")
# signed_cred.setAttribute("xsi:schemaLocation", "http://www.protogeni.net/resources/credential/ext/policy/1 http://www.protogeni.net/resources/credential/ext/policy/1/policy.xsd")
doc.appendChild(signed_cred)
# Fill in the <credential> bit
cred = doc.createElement("credential")
cred.setAttribute("xml:id", self.get_refid())
signed_cred.appendChild(cred)
append_sub(doc, cred, "type", "abac")
# Stub fields
append_sub(doc, cred, "serial", "8")
append_sub(doc, cred, "owner_gid", '')
append_sub(doc, cred, "owner_urn", '')
append_sub(doc, cred, "target_gid", '')
append_sub(doc, cred, "target_urn", '')
append_sub(doc, cred, "uuid", "")
if not self.expiration:
self.set_expiration(datetime.datetime.utcnow() + datetime.timedelta(seconds=DEFAULT_CREDENTIAL_LIFETIME))
self.expiration = self.expiration.replace(microsecond=0)
if self.expiration.tzinfo is not None and self.expiration.tzinfo.utcoffset(self.expiration) is not None:
# TZ aware. Make sure it is UTC
self.expiration = self.expiration.astimezone(tz.tzutc())
append_sub(doc, cred, "expires", self.expiration.strftime('%Y-%m-%dT%H:%M:%SZ')) # RFC3339
abac = doc.createElement("abac")
rt0 = doc.createElement("rt0")
abac.appendChild(rt0)
cred.appendChild(abac)
append_sub(doc, rt0, "version", "1.1")
head = self.createABACElement(doc, "head", self.get_head())
rt0.appendChild(head)
for tail in self.get_tails():
tailEle = self.createABACElement(doc, "tail", tail)
rt0.appendChild(tailEle)
# Create the <signatures> tag
signatures = doc.createElement("signatures")
signed_cred.appendChild(signatures)
# Get the finished product
self.xml = doc.toxml("utf-8")
def todaysNews():
query = News.all()
query.order("-createdAt")
results = query.fetch(limit=1)
mostRecentNews = results.pop()
# Create the minidom level document
doc = Document()
newsElement = doc.createElement("news")
doc.appendChild(newsElement)
#headline
headlineElement = doc.createElement("headline")
headline = doc.createTextNode(mostRecentNews.headline)
headlineElement.appendChild(headline)
newsElement.appendChild(headlineElement)
#content
contentElement = doc.createElement("content")
content = doc.createTextNode(mostRecentNews.content)
contentElement.appendChild(content)
newsElement.appendChild(contentElement)
#date
dateElement = doc.createElement("date")
date = doc.createTextNode(str(mostRecentNews.createdAt))
dateElement.appendChild(date)
newsElement.appendChild(dateElement)
out = doc.toxml()
return out
def get(self):
method = self.request.get('method')
logging.debug(method)
if method == "photo.list.all":
doc = Document()
root = doc.createElement("channel")
doc.appendChild(root)
obj_contents = photolog_list_all('',5)
for obj in obj_contents:
dom = parseString(obj.to_xml().encode('utf-8'))
root.appendChild(dom.getElementsByTagName("entity")[0])
elif method == "user.info":
doc = Document()
root = doc.createElement("channel")
doc.appendChild(root)
key = method = self.request.get('key')
userinfo = get_user_by_key(key)
dom = parseString(userinfo.to_xml().encode('utf-8'))
root.appendChild(dom.getElementsByTagName("entity")[0])
elif method == "photo.one":
gkey = self.request.get('gkey')
if gkey:
obj = photolog_get_node(gkey)
doc = obj.get_info_in_xml()
#dom = parseString(obj.to_xml().encode('utf-8'))
#root.appendChild(dom.getElementsByTagName("entity")[0])
else:
return
self.response.out.write(doc.toxml())
def onResult(self, data):
doc = Document()
listentext = doc.createElement("listenText")
doc.appendChild(listentext)
if len(data) <= 1:
listentext.setAttribute("state", "RecognitionFailed")
else:
try:
i = 0
for r in data['result']:
i += 1
rank = str(i)
if 'confidence' in r:
score = str(r['confidence'])
else:
score = 0.0
text = r['str']
hypo = doc.createElement("data")
hypo.setAttribute("rank", rank)
hypo.setAttribute("score", score)
hypo.setAttribute("likelihood", score)
hypo.setAttribute("text", text)
rospy.loginfo("#%s: %s (%s)" %
(rank, text.encode('utf-8'), score))
listentext.appendChild(hypo)
listentext.setAttribute("state", "Success")
except:
print(traceback.format_exc())
listentext.setAttribute("state", "ParseError")
res_data = doc.toxml(encoding="utf-8")
self._julius_result.publish(res_data.decode('unicode_escape'))
def onResult(self, data):
doc = Document()
listentext = doc.createElement("listenText")
doc.appendChild(listentext)
if len(data) <= 1:
listentext.setAttribute("state", "RecognitionFailed")
else:
try:
i = 0
for r in data['result']:
i += 1
rank = str(i)
if 'confidence' in r:
score = str(r['confidence'])
else:
score = 0.0
text = r['str']
hypo = doc.createElement("data")
hypo.setAttribute("rank", rank)
hypo.setAttribute("score", score)
hypo.setAttribute("likelihood", score)
hypo.setAttribute("text", text)
self._logger.RTC_INFO("#%s: %s (%s)" % (rank, text, score))
listentext.appendChild(hypo)
listentext.setAttribute("state", "Success")
except:
print(traceback.format_exc())
listentext.setAttribute("state", "ParseError")
res_data = doc.toxml(encoding="utf-8")
self._outdata.data = res_data
self._outport.write()
def request_xml(self):
doc = Document()
root = doc.createElement(self.ROOT_ELEMENT)
doc.appendChild(root)
for key, value in self.data.items():
self._create_element(doc, root, key, value=value)
return doc.toxml()
class DictToXml(object): # pylint: disable=too-few-public-methods
"""Map dictionary into XML"""
def __init__(self, structure):
self.doc = Document()
root_name = str(structure.keys()[0])
root = self.doc.createElement(root_name)
self.doc.appendChild(root)
self._build(root, structure[root_name])
def _build(self, parent, structure):
if isinstance(structure, dict):
for node_name in structure:
tag = self.doc.createElement(node_name)
parent.appendChild(tag)
self._build(tag, structure[node_name])
elif isinstance(structure, list):
for node_structure in structure:
self._build(parent, node_structure)
elif structure is None:
return
else:
node_data = str(structure)
tag = self.doc.createTextNode(node_data)
parent.appendChild(tag)
def __str__(self):
# TODO implement separate method for pretty print
return self.doc.toxml()
def updateFontXML(self):
dataDoc = Document()
dataDoc.appendChild(dataDoc.createComment(xHeader + self.fontName))
fontElem = dataDoc.createElement(xFont)
dataDoc.appendChild(fontElem)
fontElem.setAttribute(xSize, str(self.fontSize))
fontElem.setAttribute(xName, self.fontName)
crElem = dataDoc.createElement(xCRInfo)
fontElem.appendChild(crElem)
if (self.crInfo != ''):
crElem.appendChild(dataDoc.createTextNode(self.crInfo))
for char in self.glyphMap:
charData = self.glyphMap[char]
glyphElem = dataDoc.createElement(xGlyph)
fontElem.appendChild(glyphElem)
glyphElem.setAttribute('char', char)
glyphElem.setAttribute(xROff, str(charData.rOffset))
glyphElem.setAttribute(
xBBox, '(' + ','.join([str(round(b, 2)) for b in charData.bbox]) + ')')
glyphElem.appendChild(dataDoc.createTextNode(charData.pathStr))
f = open(self.dataFilePath, "w")
f.write(dataDoc.toxml(encoding="utf-8"))
f.close()
def to_xml(self):
document = Document()
request_stream = document.createElementNS(XMLDOC_NAMESPACE,
STREAMER_ROOT_NODE)
request_stream.setAttribute(XMLDOC_XMLNS_ATTRIBUTE, XMLDOC_NAMESPACE)
document.appendChild(request_stream)
if self.channel_dvblink_id_ != None:
channel_id = document.createElement(STREAMER_CHANNEL_ID_NODE)
request_stream.appendChild(channel_id)
channel_id.appendChild(
document.createTextNode(str(self.channel_dvblink_id_)))
if self.client_id_ != None:
client_id = document.createElement(STREAMER_CLIENT_ID_NODE)
request_stream.appendChild(client_id)
client_id.appendChild(document.createTextNode(str(
self.client_id_)))
if self.server_address_ != None:
address = document.createElement(STREAMER_SERVER_ADDRESS_NODE)
request_stream.appendChild(address)
address.appendChild(
document.createTextNode(str(self.server_address_)))
if self.stream_type_ != None:
stream_type = document.createElement(STREAMER_STREAM_TYPE_NODE)
request_stream.appendChild(stream_type)
stream_type.appendChild(
document.createTextNode(str(self.stream_type_)))
return document.toxml(encoding=XMLDOC_CODEPAGE)
def object_to_xml(obj_file, xml_file):
"""Gnerate an XML file."""
dic_obj = open(obj_file, "rb")
if options.verbose:
print("Loading dictionary...")
dic_ip = pickle.load(dic_obj)
if options.verbose:
print("Creating XML file...")
doc = Document()
racine = doc.createElement("IP-Link")
doc.appendChild(racine)
for ip_src in dic_ip:
ipsrc = doc.createElement("ip_packet")
ipsrc.setAttribute("source_ip", ip_src)
racine.appendChild(ipsrc)
for ip_dst in dic_ip[ip_src]:
ipdst = doc.createElement("ip_packet")
ipdst.setAttribute("destination_ip", ip_dst)
ipdst.setAttribute("weight", str(dic_ip[ip_src][ip_dst]))
ipsrc.appendChild(ipdst)
# Elegant display of the XML object
# print doc.toprettyxml()
try:
file = open(xml_file, "w")
file.write("%s" % doc.toxml().encode("utf-8"))
except IOError as e:
print("Writting error :", e)
finally:
file.close()
def Serialize(self):
if not self.message:
raise TCException(
"iD message not sent, cannot serialize",
'%s.%s' % (self.__class__.__name__, current_function()))
doc = Document()
# TODO declaration bit
cacheFidx = '%d' % self.message.GetBlockIdx()
cacheEvent = '%d' % self.message.GetEvent()
fvalue = self.message.GetFamily()
self.message.absolute.Tic()
self.message.relative.Tic()
timestamp = self.message.absolute.Get()
reference = self.message.relative.Get()
root = doc.createElement(IDMESSAGE_ROOTNODE)
root.setAttribute(IDMESSAGE_VERSIONNODE, IDMESSAGE_VERSION)
root.setAttribute(IDMESSAGE_DESCRIPTIONNODE,
self.message.GetDescription())
root.setAttribute(IDMESSAGE_FRAMENODE, cacheFidx)
root.setAttribute(IDMESSAGE_FAMILYNODE, fvalue)
root.setAttribute(IDMESSAGE_EVENTNODE, cacheEvent)
root.setAttribute(IDMESSAGE_TIMESTAMPNODE, timestamp)
root.setAttribute(IDMESSAGE_REFERENCENODE, reference)
doc.appendChild(root)
# TODO indent?
return doc.toxml()
def request(self, host, handler, request_body, verbose=False):
"""
ist für den Aufruf der Methoden auf dem Server zuständig.
Die XML-Nachrichten werden manuell zusammengebaut und dann zu dem Host gesendet.
"""
doc = parseString(request_body)
connectionelement = doc.createElement("connection")
if self.src_ip:
connectionelement.setAttribute("srcip", self.src_ip)
connectionelement.setAttribute("dstip", host)
ps = doc.getElementsByTagName('methodCall')[0]
ps.insertBefore(connectionelement, ps.firstChild)
xmldata = base64.b64encode(bytes(doc.toxml(), 'UTF-8'))
message = Document()
msgnode = message.createElement('message')
message.appendChild(msgnode)
xmlnode = message.createElement('xmldata')
xmlnode.appendChild(message.createTextNode(xmldata.decode("utf-8")))
msgnode.appendChild(xmlnode)
signaturenode = message.createElement('signature')
signaturenode.appendChild(message.createTextNode(self.sign(xmldata).decode("utf-8")))
msgnode.appendChild(signaturenode)
return super().request(host, handler, bytes(message.toxml(), 'UTF-8'), verbose)
def Hand_Allbooklist_Get(request):
serialid = request.META.get('HTTP_SERIAL', '')
resultCode = '0'
returnXmlData = ''
if serialid == '':
resultCode = '1018'
return resultCode, returnXmlData
try:
dataList = recentbooklist.objects.values(
"bookName", "bookId").filter(serial=serialid)
except:
print(
"Hand_Allbooklist_Get select database of table recentbooklist faile!!!!!"
)
resultCode = '1028'
return resultCode, returnXmlData
if dataList:
doc = Document()
root = doc.createElement('Response')
doc.appendChild(root)
getRecentListReq = doc.createElement('GetRecentListReq')
root.appendChild(getRecentListReq)
for value in dataList:
Add_Element(doc, getRecentListReq, value)
else:
return resultCode, returnXmlData
# print (doc.toxml('UTF-8'))
returnxmlData = doc.toxml('UTF-8')
return resultCode, returnxmlData
def generate_ticket_body(subject_text, body_text, requester_email_text,
use_configured_assignee=True):
doc = Document()
# Create the outer ticket element
ticket = doc.createElement("ticket")
doc.appendChild(ticket)
# Create the other data
subject = doc.createElement('subject')
subject.appendChild(doc.createTextNode(subject_text))
ticket.appendChild(subject)
requester = doc.createElement('requester-email')
requester.appendChild(doc.createTextNode(requester_email_text))
ticket.appendChild(requester)
requester = doc.createElement('group-id')
requester.appendChild(doc.createTextNode('86020'))
ticket.appendChild(requester)
if (use_configured_assignee and
getattr(settings, "ZENDESK_ASSIGN_TO_USER_ID", None)):
value = getattr(settings, "ZENDESK_ASSIGN_TO_USER_ID")
assignee = doc.createElement('assignee-id')
assignee.appendChild(doc.createTextNode(unicode(value)))
ticket.appendChild(assignee)
description = doc.createElement('description')
description.appendChild(doc.createTextNode(body_text))
ticket.appendChild(description)
return doc.toxml()
def to_xml(self):
document = Document()
schedule = document.createElementNS(XMLDOC_NAMESPACE,
SCHEDULE_ROOT_NODE)
schedule.setAttribute(XMLDOC_XMLNS_ATTRIBUTE, XMLDOC_NAMESPACE)
document.appendChild(schedule)
# schedule id
if self.schedule_id_ != None:
schedule_id_node = document.createElement(SCHEDULE_ID_NODE)
schedule.appendChild(schedule_id_node)
schedule_id_node.appendChild(
document.createTextNode(self.schedule_id_))
# user param
if self.user_param_ != None:
user_param_node = document.createElement(SCHEDULE_USER_PARAM_NODE)
schedule.appendChild(user_param_node)
user_param_node.appendChild(
document.createTextNode(self.user_param_))
# force add
if self.force_add_:
force_add_node = document.createElement(SCHEDULE_FORCE_ADD_NODE)
schedule.appendChild(force_add_node)
force_add_node.appendChild(
document.createTextNode(XMLNODE_VALUE_TRUE))
# by epg
if self.by_epg_ != None:
by_epg_node = self.by_epg_.create_node(document)
schedule.appendChild(by_epg_node)
# manual
if self.manual_ != None:
manual_node = self.manual_.create_node(document)
schedule.appendChild(manual_node)
return document.toxml(encoding=XMLDOC_CODEPAGE)
def doStartSession(self, args={}):
url = self.base_url + "/start.php"
doc = Document()
sessionNode = doc.createElement("session")
sessionNode.setAttribute("mode", "desktop")
userNode = doc.createElement("user")
userNode.setAttribute("login", self.conf["login"])
userNode.setAttribute("password", self.conf["password"])
sessionNode.appendChild(userNode)
if args.has_key("start-apps"): # launch applications at the session startup
startappsNode = doc.createElement("start")
for appid in args["start-apps"]:
appNode = doc.createElement("application")
appNode.setAttribute("id", appid)
startappsNode.appendChild(appNode)
sessionNode.appendChild(startappsNode)
doc.appendChild(sessionNode)
request = urllib2.Request(url, doc.toxml())
try:
url = self.urlOpener.open(request)
except urllib2.HTTPError, exc:
if exc.code == 500:
Logger.info("The service is not available")
return False
Logger.debug("HTTP request return code %d (%s)" % (exc.code, exc.msg))
return False
def to_xml(self):
document = Document()
schedule = document.createElementNS(XMLDOC_NAMESPACE,
SCHEDULE_UPDATE_ROOT_NODE)
schedule.setAttribute(XMLDOC_XMLNS_ATTRIBUTE, XMLDOC_NAMESPACE)
document.appendChild(schedule)
if self.schedule_id_ != None:
schedule_id_node = document.createElement(SCHEDULE_ID_NODE)
schedule.appendChild(schedule_id_node)
schedule_id_node.appendChild(
document.createTextNode(self.schedule_id_))
if self.is_new_only_:
is_new_only_node = document.createElement(SCHEDULE_NEW_ONLY_NODE)
schedule.appendChild(is_new_only_node)
is_new_only_node.appendChild(
document.createTextNode(XMLNODE_VALUE_TRUE))
if self.is_record_series_anytime_:
is_record_series_anytime_node = document.createElement(
SCHEDULE_SERIES_ANYTIME_NODE)
schedule.appendChild(is_record_series_anytime_node)
is_record_series_anytime_node.appendChild(
document.createTextNode(XMLNODE_VALUE_TRUE))
if self.recordings_to_keep_ != None:
recordings_to_keep_node = document.createElement(
SCHEDULE_REC_TO_KEEP_NODE)
schedule.appendChild(recordings_to_keep_node)
recordings_to_keep_node.appendChild(
document.createTextNode(str(self.recordings_to_keep_)))
return document.toxml(encoding=XMLDOC_CODEPAGE)
def list_bucket(self):
dirL = self.user.list_bucket(self.bucketName, self.request.args)
doc = Document()
# Create the <wml> base element
xList = doc.createElement("ListBucketResult")
xList.setAttribute("xmlns", "http://doc.s3.amazonaws.com/2006-03-01")
doc.appendChild(xList)
# Create the main <card> element
xName = doc.createElement("Name")
xList.appendChild(xName)
xNameText = doc.createTextNode(str(self.bucketName))
xName.appendChild(xNameText)
xIsTruncated = doc.createElement("IsTruncated")
xList.appendChild(xIsTruncated)
xIsTText = doc.createTextNode('false')
xIsTruncated.appendChild(xIsTText)
for obj in dirL:
xObj = obj.create_xml_element(doc)
xList.appendChild(xObj)
x = doc.toxml();
self.send_xml(x)
self.finish(self.request)
def to_xml(self):
document = Document()
schedules = document.createElementNS(XMLDOC_NAMESPACE,
SCHEDULES_ROOT_NODE)
schedules.setAttribute(XMLDOC_XMLNS_ATTRIBUTE, XMLDOC_NAMESPACE)
document.appendChild(schedules)
return document.toxml(encoding=XMLDOC_CODEPAGE)
def testTaxes2(self):
doc = Document()
parent_node = doc.createElement('parent_node')
doc.appendChild(parent_node)
data = {
'default-tax-table': {
'tax-rules': [
{
'shipping-taxed': True,
'rate': 0.06,
'tax-area': {
'us-state-area': ['CT'],
}
},
{
'rate': 0.05,
'tax-area': {
'us-state-area': ['MD'],
}
}
]
}
}
self.gc._taxes(doc, parent_node, data)
xml1 = "<parent_node><tax-tables><default-tax-table><tax-rules>\
<default-tax-rule><shipping-taxed>true</shipping-taxed><rate>0.06</rate>\
<tax-area><us-state-area><state>CT</state></us-state-area></tax-area>\
</default-tax-rule><default-tax-rule><shipping-taxed>false</shipping-taxed>\
<rate>0.05</rate><tax-area><us-state-area><state>MD</state></us-state-area>\
</tax-area></default-tax-rule></tax-rules></default-tax-table></tax-tables>\
</parent_node>"
doc_good = parseString(xml1)
self.assertEquals(doc.toxml(), doc_good.toxml())
def doLogout(self):
if self.sessionProperties["persistent"]:
mode = "suspend"
else:
mode = "logout"
document = Document()
rootNode = document.createElement("logout")
rootNode.setAttribute("mode", mode)
document.appendChild(rootNode)
url = "%s/logout" % (self.base_url)
request = urllib2.Request(url)
request.add_header("Content-type", "text/xml; charset=UTF-8")
request.add_data(document.toxml())
try:
url = self.urlOpener.open(request)
except urllib2.HTTPError, exc:
logging.debug(" * return: %s" % (str(exc.read())))
if exc.code == 500:
raise OvdExceptionNotAvailable()
raise OvdExceptionInternalError(
"HTTP request return code %d (%s)" % (exc.code, exc.msg))
def distributePlan(txn, targets, plan):
m = Document()
message = m.appendChild(m.createElement('message'))
message.setAttribute('kind', 'distribution')
targetNodes = message.appendChild(m.createElement('targets'))
planNode = message.appendChild(m.createElement('plan'))
for t in targets:
newTarget = m.createElement('target')
for k,v in t.itervalues():
newTarget.setAttribute(k,v)
targetNodes.appendChild(newTarget)
for k,v in plan.itervalues():
if k is 'plan':
continue
planNode.setAttribute(k,v)
planNode.appendChild(m.createTextNode(plan['plan']))
peers = txn.execute(
'SELECT peer FROM healing_group ORDER BY peer'
).fetchall()
writer = BundleWriter('dtnhealing:')
for p in peers:
writer.write(p['peer'], m.toxml())
return targets, plan
def doStartSession(self, args={}):
url = self.base_url + "/start"
doc = Document()
sessionNode = doc.createElement("session")
sessionNode.setAttribute("mode", "desktop")
if self.conf.has_key("language") and self.conf["language"]:
sessionNode.setAttribute("language", self.conf["language"])
userNode = doc.createElement("user")
userNode.setAttribute("login", self.conf["login"])
userNode.setAttribute("password", self.conf["password"])
sessionNode.appendChild(userNode)
if args.has_key(
"start-apps"): # launch applications at the session startup
startappsNode = doc.createElement("start")
for appid in args["start-apps"]:
appNode = doc.createElement("application")
appNode.setAttribute("id", appid)
startappsNode.appendChild(appNode)
sessionNode.appendChild(startappsNode)
doc.appendChild(sessionNode)
request = urllib2.Request(url, doc.toxml())
try:
url = self.urlOpener.open(request)
except urllib2.HTTPError, exc:
if exc.code == 500:
raise OvdExceptionNotAvailable()
raise OvdExceptionInternalError(
"HTTP request return code %d (%s)" % (exc.code, exc.msg))
def encode(self):
# Create the XML document
doc = Document()
signed_cred = doc.createElement("signed-credential")
# Declare namespaces
# Note that credential/policy.xsd are really the PG schemas
# in a PL namespace.
# Note that delegation of credentials between the 2 only really works
# cause those schemas are identical.
# Also note these PG schemas talk about PG tickets and CM policies.
signed_cred.setAttribute("xmlns:xsi", "http://www.w3.org/2001/XMLSchema-instance")
signed_cred.setAttribute("xsi:noNamespaceSchemaLocation", "http://www.geni.net/resources/credential/2/credential.xsd")
signed_cred.setAttribute("xsi:schemaLocation", "http://www.planet-lab.org/resources/sfa/ext/policy/1 http://www.planet-lab.org/resources/sfa/ext/policy/1/policy.xsd")
# PG says for those last 2:
# signed_cred.setAttribute("xsi:noNamespaceSchemaLocation", "http://www.protogeni.net/resources/credential/credential.xsd")
# signed_cred.setAttribute("xsi:schemaLocation", "http://www.protogeni.net/resources/credential/ext/policy/1 http://www.protogeni.net/resources/credential/ext/policy/1/policy.xsd")
doc.appendChild(signed_cred)
# Fill in the <credential> bit
cred = doc.createElement("credential")
cred.setAttribute("xml:id", self.get_refid())
signed_cred.appendChild(cred)
append_sub(doc, cred, "type", "abac")
# Stub fields
append_sub(doc, cred, "serial", "8")
append_sub(doc, cred, "owner_gid", '')
append_sub(doc, cred, "owner_urn", '')
append_sub(doc, cred, "target_gid", '')
append_sub(doc, cred, "target_urn", '')
append_sub(doc, cred, "uuid", "")
if not self.expiration:
self.set_expiration(datetime.datetime.utcnow() + datetime.timedelta(seconds=DEFAULT_CREDENTIAL_LIFETIME))
self.expiration = self.expiration.replace(microsecond=0)
if self.expiration.tzinfo is not None and self.expiration.tzinfo.utcoffset(self.expiration) is not None:
# TZ aware. Make sure it is UTC
self.expiration = self.expiration.astimezone(tz.tzutc())
append_sub(doc, cred, "expires", self.expiration.strftime('%Y-%m-%dT%H:%M:%SZ')) # RFC3339
abac = doc.createElement("abac")
rt0 = doc.createElement("rt0")
abac.appendChild(rt0)
cred.appendChild(abac)
append_sub(doc, rt0, "version", "1.1")
head = self.createABACElement(doc, "head", self.get_head())
rt0.appendChild(head)
for tail in self.get_tails():
tailEle = self.createABACElement(doc, "tail", tail)
rt0.appendChild(tailEle)
# Create the <signatures> tag
signatures = doc.createElement("signatures")
signed_cred.appendChild(signatures)
# Get the finished product
self.xml = doc.toxml("utf-8")
def object_to_xml(obj_file, xml_file):
"""Gnerate an XML file."""
dic_obj = open(obj_file, "r")
if options.verbose:
print("Loading dictionary...")
dic_ip = pickle.load(dic_obj)
if options.verbose:
print("Creating XML file...")
doc = Document()
racine = doc.createElement("IP-Link")
doc.appendChild(racine)
for ip_src in dic_ip:
ipsrc = doc.createElement("ip_packet")
ipsrc.setAttribute("source_ip", ip_src)
racine.appendChild(ipsrc)
for ip_dst in dic_ip[ip_src]:
ipdst = doc.createElement("ip_packet")
ipdst.setAttribute("destination_ip", ip_dst)
ipdst.setAttribute("weight", str(dic_ip[ip_src][ip_dst]))
ipsrc.appendChild(ipdst)
# Elegant display of the XML object
#print doc.toprettyxml()
try:
file = open(xml_file, 'w')
file.write('%s' % doc.toxml().encode('utf-8'))
except IOError as e:
print("Writting error :", e)
finally:
file.close()
def constructLogXml(event, comment):
eventString = str(event)
commentString = str(comment)
doc = Document()
#Create root
root = doc.createElement('log_entry')
doc.appendChild(root)
#Add event
event = doc.createElement('event')
root.appendChild(event)
eventText = doc.createTextNode(eventString)
event.appendChild(eventText)
#Add timestamp
time = doc.createElement('time')
root.appendChild(time)
timeText = doc.createTextNode(datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S"))
time.appendChild(timeText)
#Add cell ID
cell = doc.createElement('cell_id')
root.appendChild(cell)
cellText = doc.createTextNode('4')
cell.appendChild(cellText)
#add comment
comment = doc.createElement('comment')
root.appendChild(comment)
commentText = doc.createTextNode(commentString)
comment.appendChild(commentText)
return doc.toxml(encoding="utf-8")
def xmlify(self, aHost, encryptedMessage):
### xmlifies the current message, building an onion as it goes.
# open a file, write to it the xml-ified version of the query
# structure:
# <transmission>
# <next-hop> a hop </next-hop>
# <encrypted block>
# (encrypted block contains one of these same blocks)
# </encrypted block>
# </transmission>
# using xml.dom.minidom will autosanitize input!
PDSMessage = Document()
transmission = doc.createElement(TRANSMISSION)
PDSMessage.appendChild(transmission)
next_hop = doc.createElement(NEXT_HOP)
transmission.appendChild(next_hop)
nextHopText = doc.createTextElement(aHost)
next_hop.appendChild(nextHopText)
encrypted_block = doc.createElement(ENCRYPTED_BLOCK)
transmission.appendChild(encrypted_block)
encryptedText = doc.createTextElement(encryptedMessage)
encrypted_block.appendChild(encryptedText)
## TODO: this little bit is maybe not quite right -- I don't know if this syntax is correct.
return PDSMessage.toxml()
def list_bucket(self):
dirL = self.user.list_bucket(self.bucketName, self.request.args)
doc = Document()
# Create the <wml> base element
xList = doc.createElement("ListBucketResult")
xList.setAttribute("xmlns", "http://doc.s3.amazonaws.com/2006-03-01")
doc.appendChild(xList)
# Create the main <card> element
xName = doc.createElement("Name")
xList.appendChild(xName)
xNameText = doc.createTextNode(str(self.bucketName))
xName.appendChild(xNameText)
xIsTruncated = doc.createElement("IsTruncated")
xList.appendChild(xIsTruncated)
xIsTText = doc.createTextNode('false')
xIsTruncated.appendChild(xIsTText)
for obj in dirL:
xObj = obj.create_xml_element(doc)
xList.appendChild(xObj)
x = doc.toxml()
self.send_xml(x)
self.finish(self.request)
def export_tar(request):
data = _get_data(request)
arch_file = StringIO()
arch = tarfile.TarFile(fileobj=arch_file, mode="w")
for note in data:
doc = Document()
root = _note_to_xml(doc, note)
doc.appendChild(root)
note_data = doc.toxml(encoding='utf-8')
note_file = StringIO()
note_file.write(note_data)
note_file.seek(0)
note_info = tarfile.TarInfo("%s.note" % note["guid"])
note_info.size = len(note_data)
note_info.mtime = time.mktime(
parse_iso_time(note["last-change-date"]).timetuple())
arch.addfile(tarinfo=note_info, fileobj=note_file)
arch.close()
response = HttpResponse(arch_file.getvalue())
response["Content-Type"] = "application/x-tar"
response[
"Content-Disposition"] = "attachment; filename=snowy-%s-%s.tar" % (
request.user, time.strftime("%Y-%m-%d"))
return response
def export_tar(request):
data = _get_data(request)
arch_file = StringIO()
arch = tarfile.TarFile(fileobj=arch_file, mode="w")
for note in data:
doc = Document()
root = _note_to_xml(doc, note)
doc.appendChild(root)
note_data = doc.toxml(encoding='utf-8')
note_file = StringIO()
note_file.write(note_data)
note_file.seek(0)
note_info = tarfile.TarInfo("%s.note" % note["guid"])
note_info.size = len(note_data)
note_info.mtime = time.mktime(parse_iso_time(note["last-change-date"]).timetuple())
arch.addfile(
tarinfo=note_info,
fileobj=note_file
)
arch.close()
response = HttpResponse(arch_file.getvalue())
response["Content-Type"] = "application/x-tar"
response["Content-Disposition"] = "attachment; filename=snowy-%s-%s.tar" % (request.user, time.strftime("%Y-%m-%d"))
return response
def end_copy(self):
try:
self.user.put_object(self.dst_file, self.dstBucketName,
self.dstObjectName)
self.grant_public_permissions(self.dstBucketName,
self.dstObjectName)
doc = Document()
cor = doc.createElement("CopyObjectResult")
doc.appendChild(cor)
lm = doc.createElement("LastModified")
cor.appendChild(lm)
lmText = doc.createTextNode(
datetime(*self.src_ctm[:6]).isoformat())
lm.appendChild(lmText)
lm = doc.createElement("ETag")
cor.appendChild(lm)
lmText = doc.createTextNode(str(self.src_md5))
lm.appendChild(lmText)
x = doc.toxml()
self.setHeader(self.request, 'x-amz-copy-source-version-id', "1")
self.setHeader(self.request, 'x-amz-version-id', "1")
self.send_xml(x)
self.request.finish()
except cbException, (ex):
ex.sendErrorResponse(self.request, self.requestId)
traceback.print_exc(file=sys.stdout)
def textToXML(headers, text):
"""convert text to Scripting News XML
Returns: string, complete XML output as single string
Arguments:
- headers: dictionary of additional headers for <header> node;
some of these are required, see http://my.userland.com/stories/storyReader$11
- text: text to convert
"""
scriptingNewsNode = Element("scriptingNews")
headernode = Element("header")
headernode.appendChild(_TextElement("scriptingNewsVersion", "2.0b1"))
headernode.appendChild(_TextElement("docs", "http://my.userland.com/stories/storyReader$11"))
for k, v in headers.items():
headernode.appendChild(_TextElement(k, v))
scriptingNewsNode.appendChild(headernode)
itemlist = text.split("\n\n")
for itemtext in itemlist:
itemnode = Element("item")
itemtext, linklist = _parseItem(itemtext)
itemnode.appendChild(_TextElement("text", itemtext))
for link in linklist:
linknode = Element("link")
url, linetext = link
linknode.appendChild(_TextElement("url", url))
linknode.appendChild(_TextElement("linetext", linetext))
itemnode.appendChild(linknode)
scriptingNewsNode.appendChild(itemnode)
doc = Document()
doc.appendChild(scriptingNewsNode)
return doc.toxml()
def write_inds_2_xml(inds, res_path):
"""
This function writes the individuals minidom Node into an XML file.
Parameters
----------
inds : list of xml minidom Node
All the individuals to be written to the xml file.
res_path : str
The file path of the XML file.
"""
#write an xml file
doc = Document()
root_node = doc.createElement("data")
doc.appendChild(root_node)
population = doc.createElement("population")
root_node.appendChild(population)
doc = xml.dom.minidom.parseString("<data><population></population></data>")
parent_node = doc.getElementsByTagName("population")[0]
for ind_node in inds:
parent_node.appendChild(ind_node)
f = open(res_path, "w")
f.write(doc.toxml())
f.close()
def parseRss(l, info):
feed = Document()
rss = feed.createElement("rss")
channel = feed.createElement("channel")
title = feed.createElement("title")
title_text = feed.createTextNode(info["title"])
link = feed.createElement("link")
link_text = feed.createTextNode(info["root"])
title.appendChild(title_text)
link.appendChild(link_text)
channel.appendChild(title)
channel.appendChild(link)
for p in l:
item = feed.createElement('item')
pair = {\
'title':p['title'], 'description':p['content'],\
'link':info['root']+'/'+p['rlink']}
for n in pair.keys():
node = feed.createElement(n)
node_text = feed.createTextNode(pair[n])
node.appendChild(node_text)
item.appendChild(node)
channel.appendChild(item)
rss.appendChild(channel)
feed.appendChild(rss)
return feed.toxml()
def testTaxes2(self):
doc = Document()
parent_node = doc.createElement('parent_node')
doc.appendChild(parent_node)
data = {
'default-tax-table': {
'tax-rules': [
{
'shipping-taxed': True,
'rate': 0.06,
'tax-area': {
'us-state-area': ['CT'],
}
},
{
'rate': 0.05,
'tax-area': {
'us-state-area': ['MD'],
}
}
]
}
}
self.gc._taxes(doc, parent_node, data)
xml1 = "<parent_node><tax-tables><default-tax-table><tax-rules>\
<default-tax-rule><shipping-taxed>true</shipping-taxed><rate>0.06</rate>\
<tax-area><us-state-area><state>CT</state></us-state-area></tax-area>\
</default-tax-rule><default-tax-rule><shipping-taxed>false</shipping-taxed>\
<rate>0.05</rate><tax-area><us-state-area><state>MD</state></us-state-area>\
</tax-area></default-tax-rule></tax-rules></default-tax-table></tax-tables>\
</parent_node>"
doc_good = parseString(xml1)
self.assertEquals(doc.toxml(), doc_good.toxml())
def getDocument(dataset):
gzSupport.addMessage(dataset)
desc = arcpy.Describe(dataset)
xmlDoc = Document()
root = xmlDoc.createElement('table')
xmlDoc.appendChild(root)
root.setAttribute("xmlns",'http://gizinta.com')
if desc.baseName.find('.') > -1:
baseName = desc.baseName[desc.baseName.rfind('.')+1:]
else:
baseName = desc.baseName
source = xmlDoc.createElement("data")
source.setAttribute("name",baseName)
root.appendChild(source)
fields = getFields(dataset)
i=0
try:
for field in fields:
fNode = xmlDoc.createElement("row")
fNode.setAttribute("id",str(i))
source.appendChild(fNode)
addFieldElement(xmlDoc,fNode,"FieldName",field.name)
addFieldElement(xmlDoc,fNode,"SourceField","")
addFieldElement(xmlDoc,fNode,"SourceQA","Required") # need to get these values from template project.
addFieldElement(xmlDoc,fNode,"TargetQA","Required")
addFieldElement(xmlDoc,fNode,"SourceMethod","Copy")
addFieldElement(xmlDoc,fNode,"FieldType",field.type)
addFieldElement(xmlDoc,fNode,"FieldLength",str(field.length))
i += 1
xmlStr = xmlDoc.toxml()
except:
gzSupport.showTraceback()
xmlStr =""
return xmlStr
def testTaxes3(self):
doc = Document()
parent_node = doc.createElement('parent_node')
doc.appendChild(parent_node)
data = {
'default-tax-table': {
'tax-rules': [
{
'shipping-taxed': False,
'rate': 0.08375,
'tax-area': {
'us-zip-area': ['100*'],
}
},
{
'shipping-taxed': True,
'rate': 0.04,
'tax-area': {
'us-state-area': ['NY'],
}
}
]
}
}
self.gc._taxes(doc, parent_node, data)
xml1 = "<parent_node><tax-tables><default-tax-table>\
<tax-rules><default-tax-rule><shipping-taxed>false</shipping-taxed>\
<rate>0.08375</rate><tax-area><us-zip-area><zip-pattern>100*</zip-pattern>\
</us-zip-area></tax-area></default-tax-rule>\
<default-tax-rule><shipping-taxed>true</shipping-taxed>\
<rate>0.04</rate><tax-area><us-state-area><state>NY</state></us-state-area>\
</tax-area></default-tax-rule>\
</tax-rules></default-tax-table></tax-tables></parent_node>"
doc_good = parseString(xml1)
self.assertEquals(doc.toxml(), doc_good.toxml())
def make_xml_string(self, path, requestId):
doc = Document()
# Create the <wml> base element
xError = doc.createElement("Error")
doc.appendChild(xError)
# Create the main <card> element
xCode = doc.createElement("Code")
xCodeText = doc.createTextNode(self.code)
xCode.appendChild(xCodeText)
xError.appendChild(xCode)
xMsg = doc.createElement("Message")
xMsgText = doc.createTextNode(self.eMsg)
xMsg.appendChild(xMsgText)
xError.appendChild(xMsg)
xRsc = doc.createElement("Resource")
xRscText = doc.createTextNode(path)
xRsc.appendChild(xRscText)
xError.appendChild(xRsc)
xRId = doc.createElement("RequestId")
xRIdText = doc.createTextNode(str(requestId))
xRId.appendChild(xRIdText)
xError.appendChild(xRId)
for k in self.custom_xml.keys():
xId = doc.createElement(k)
xText = doc.createTextNode(self.custom_xml[k])
xId.appendChild(xText)
xError.appendChild(xId)
return doc.toxml()
def testTaxes7(self):
doc = Document()
parent_node = doc.createElement('parent_node')
doc.appendChild(parent_node)
data = {
'default-tax-table': {
'tax-rules': [
{
'shipping-taxed': True,
'rate': 0.175,
'tax-area': {
'postal-area': [
{'country-code': 'DE'},
{'country-code': 'ES'},
{'country-code': 'GB'},
],
},
},
]
},
}
self.gc._taxes(doc, parent_node, data)
xml1 = "<parent_node><tax-tables>\
<default-tax-table><tax-rules><default-tax-rule>\
<shipping-taxed>true</shipping-taxed><rate>0.175</rate>\
<tax-areas><postal-area><country-code>DE</country-code>\
</postal-area><postal-area><country-code>ES</country-code>\
</postal-area><postal-area><country-code>GB</country-code>\
</postal-area></tax-areas></default-tax-rule></tax-rules>\
</default-tax-table></tax-tables></parent_node>"
doc_good = parseString(xml1)
self.assertEquals(doc.toxml(), doc_good.toxml())
def do_call_exit(self):
if d.sessionProperties["persistent"]:
mode = "suspend"
else:
mode = "logout"
document = Document()
rootNode = document.createElement("logout")
rootNode.setAttribute("mode", mode)
document.appendChild(rootNode)
url = "%s/logout.php" % (self.base_url)
request = urllib2.Request(url)
request.add_header("Content-type", "text/xml; charset=UTF-8")
request.add_data(document.toxml())
try:
url = self.urlOpener.open(request)
except urllib2.HTTPError, exc:
if exc.code == 500:
Logger.warn("Service failurek")
return False
Logger.debug("HTTP request return code %d (%s)" % (exc.code, exc.msg))
Logger.debug(" * return: %s" % (str(exc.read())))
return False
def testShippingExclude(self):
doc = Document()
parent_node = doc.createElement('parent_node')
doc.appendChild(parent_node)
data = {
'us-state-area': ['AK','HI'],
'us-zip-area': ['90210', '04005', '04092'],
'us-country-area': 'CONTINENTAL_48',
'world-area': True,
'postal-area': [{
'country-code': 'US',
'postal-code-pattern': ['94043', '90211'],
},
],
}
self.gc._shipping_allowed_excluded(doc, parent_node, data)
xml1 = "<parent_node><us-state-area><state>AK</state></us-state-area>\
<us-state-area><state>HI</state></us-state-area>\
<us-zip-area><zip-pattern>90210</zip-pattern></us-zip-area>\
<us-zip-area><zip-pattern>04005</zip-pattern></us-zip-area>\
<us-zip-area><zip-pattern>04092</zip-pattern></us-zip-area>\
<us-country-area country-area='CONTINENTAL_48'/>\
<world-area/>\
<postal-area><country-code>US</country-code>\
<postal-code-pattern>94043</postal-code-pattern>\
<postal-code-pattern>90211</postal-code-pattern></postal-area>\
</parent_node>"
doc_good = parseString(xml1)
self.assertEquals(doc.toxml(), doc_good.toxml())
class DictToXml(object): # pylint: disable=too-few-public-methods
"""Map dictionary into XML"""
def __init__(self, structure):
self.doc = Document()
root_name = str(structure.keys()[0])
root = self.doc.createElement(root_name)
self.doc.appendChild(root)
self._build(root, structure[root_name])
def _build(self, parent, structure):
if isinstance(structure, dict):
for node_name in structure:
tag = self.doc.createElement(node_name)
parent.appendChild(tag)
self._build(tag, structure[node_name])
elif isinstance(structure, list):
for node_structure in structure:
self._build(parent, node_structure)
elif structure is None:
return
else:
node_data = str(structure)
tag = self.doc.createTextNode(node_data)
parent.appendChild(tag)
def __str__(self):
# TODO implement separate method for pretty print
return self.doc.toxml()
def update(self):
try:
print 'updating server with current markers:', self.markers.keys()
doc = Document()
table = doc.appendChild(doc.createElement(u'table'))
table.setAttribute(u'id', unicode(self.device_id))
for id in self.markers.keys():
marker = table.appendChild(doc.createElement(u'marker'))
marker.setAttribute(u'id', unicode(id))
marker.setAttribute(u'angle',
unicode(self.markers[marker].angle))
marker.setAttribute(u'xpos',
unicode(self.markers[marker].xpos))
marker.setAttribute(u'ypos',
unicode(self.markers[marker].ypos))
try:
bridge = self.bus.get_object(turk.TURK_BRIDGE_SERVICE,
'/Bridge')
bridge.PublishUpdate('app',
doc.toxml(),
unicode(DRIVER_ID),
reply_handler=lambda *args: None,
error_handler=self.handle_error)
except dbus.DBusException, e:
print 'interacTable: error posting data to app', e
# Remove all markers from list
self.markers.clear()
def end_copy(self):
try:
self.user.put_object(self.dst_file, self.dstBucketName, self.dstObjectName)
self.grant_public_permissions(self.dstBucketName, self.dstObjectName)
doc = Document()
cor = doc.createElement("CopyObjectResult")
doc.appendChild(cor)
lm = doc.createElement("LastModified")
cor.appendChild(lm)
lmText = doc.createTextNode(datetime(*self.src_ctm[:6]).isoformat())
lm.appendChild(lmText)
lm = doc.createElement("ETag")
cor.appendChild(lm)
lmText = doc.createTextNode(str(self.src_md5))
lm.appendChild(lmText)
x = doc.toxml();
self.setHeader(self.request, 'x-amz-copy-source-version-id', "1")
self.setHeader(self.request, 'x-amz-version-id', "1")
self.send_xml(x)
self.request.finish()
except cbException, (ex):
ex.sendErrorResponse(self.request, self.requestId)
traceback.print_exc(file=sys.stdout)
def saveImageInfoByTitleId(site,request):
titleid=request.POST.get('titleid','')
if titleid:
titlequery=Title.objects.filter(site=site.get('id')).filter(pk=titleid)[:1]
title=None
if 1==len(titlequery):
title=titlequery[0]
if title and title.type in SWFUPLOAD_TITLE_TYPE:
from xml.dom.minidom import Document
xml=Document()
datas=xml.createElement('datas')
datas.setAttribute('userid',str(request.user.pk))
xml.appendChild(datas)
for i in range(0,int(request.POST.get('num'))):
id=request.POST.get('id'+str(i))
if id:
paperImage=PaperImage.objects.get(pk=id)
else:
paperImage=PaperImage()
paperImage.img=''
paperImage.imgmid=''
paperImage.imgsmall=''
paperImage.title=title
paperImage.content=request.POST.get('text'+str(i))
paperImage.index=int(request.POST.get('index'+str(i)))
paperImage.save()
data=xml.createElement('data')
data.setAttribute('imgid',str(paperImage.id))
data.setAttribute('imgindex',str(paperImage.index))
datas.appendChild(data)
return HttpResponse(xml.toxml('utf-8'))
return HttpResponse()
def questions_to_aiml(questions):
punctuation = "\"`~!@#$%^&()-_=+[{]}\|;:',<.>/?"
_puncStripRE = re.compile("[" + re.escape(punctuation) + "]")
# Create the minidom document
doc = Document()
# Create the <aiml> base element
aiml = doc.createElement("aiml")
doc.appendChild(aiml)
for question, answer in questions:
patterns = (re.sub(_puncStripRE, "", question), re.sub(_puncStripRE, "*", question))
for p in patterns:
category = doc.createElement("category")
pattern = doc.createElement("pattern")
pattern.appendChild(doc.createTextNode(p.upper()))
template = doc.createElement("template")
template.appendChild(doc.createTextNode(answer))
category.appendChild(pattern)
category.appendChild(template)
aiml.appendChild(category)
# Print our newly created XML
return doc.toxml()
def to_xml(self):
doc = Document()
root = doc.createElement('patterns')
doc.appendChild(root)
for test in self.tests:
test_node = doc.createElement('test')
test_node.setAttribute('name', test.name)
options_node = doc.createElement('options')
for option in test.options:
option_node = doc.createElement('option')
option_node.setAttribute('name', option.name)
options_node.appendChild(option_node)
test_node.appendChild(options_node)
for pattern in test.patterns:
pattern_node = doc.createElement('pattern')
pattern_node.setAttribute('result', pattern.result)
pattern_node.setAttribute('probability', str(pattern.probability))
for k,v in pattern.options.iteritems():
option_node = doc.createElement('option')
option_node.setAttribute('name', k)
option_node.appendChild(doc.createTextNode(v))
pattern_node.appendChild(option_node)
test_node.appendChild(pattern_node)
root.appendChild(test_node)
return doc.toxml()
def testTaxes3(self):
doc = Document()
parent_node = doc.createElement('parent_node')
doc.appendChild(parent_node)
data = {
'default-tax-table': {
'tax-rules': [
{
'shipping-taxed': False,
'rate': 0.08375,
'tax-area': {
'us-zip-area': ['100*'],
}
},
{
'shipping-taxed': True,
'rate': 0.04,
'tax-area': {
'us-state-area': ['NY'],
}
}
]
}
}
self.gc._taxes(doc, parent_node, data)
xml1 = "<parent_node><tax-tables><default-tax-table>\
<tax-rules><default-tax-rule><shipping-taxed>false</shipping-taxed>\
<rate>0.08375</rate><tax-area><us-zip-area><zip-pattern>100*</zip-pattern>\
</us-zip-area></tax-area></default-tax-rule>\
<default-tax-rule><shipping-taxed>true</shipping-taxed>\
<rate>0.04</rate><tax-area><us-state-area><state>NY</state></us-state-area>\
</tax-area></default-tax-rule>\
</tax-rules></default-tax-table></tax-tables></parent_node>"
doc_good = parseString(xml1)
self.assertEquals(doc.toxml(), doc_good.toxml())
def doStartSession(self, args = {}):
url = self.base_url+"/start.php"
doc = Document()
sessionNode = doc.createElement('session')
sessionNode.setAttribute("mode", "desktop")
userNode = doc.createElement("user")
userNode.setAttribute("login", self.conf["login"])
userNode.setAttribute("password", self.conf["password"])
sessionNode.appendChild(userNode)
if args.has_key("start-apps"): # launch applications at the session startup
startappsNode = doc.createElement("start")
for appid in args["start-apps"]:
appNode = doc.createElement("application")
appNode.setAttribute("id", appid)
startappsNode.appendChild(appNode)
sessionNode.appendChild(startappsNode)
doc.appendChild(sessionNode)
request = urllib2.Request(url, doc.toxml())
try:
url = self.urlOpener.open(request)
except urllib2.HTTPError, exc:
if exc.code == 500:
Logger.info("The service is not available")
return False
Logger.debug("HTTP request return code %d (%s)" % (exc.code, exc.msg))
return False
def testShippingExclude(self):
doc = Document()
parent_node = doc.createElement('parent_node')
doc.appendChild(parent_node)
data = {
'us-state-area': ['AK','HI'],
'us-zip-area': ['90210', '04005', '04092'],
'us-country-area': 'CONTINENTAL_48',
'world-area': True,
'postal-area': [{
'country-code': 'US',
'postal-code-pattern': ['94043', '90211'],
},
],
}
self.gc._shipping_allowed_excluded(doc, parent_node, data)
xml1 = "<parent_node><us-state-area><state>AK</state></us-state-area>\
<us-state-area><state>HI</state></us-state-area>\
<us-zip-area><zip-pattern>90210</zip-pattern></us-zip-area>\
<us-zip-area><zip-pattern>04005</zip-pattern></us-zip-area>\
<us-zip-area><zip-pattern>04092</zip-pattern></us-zip-area>\
<us-country-area country-area='CONTINENTAL_48'/>\
<world-area/>\
<postal-area><country-code>US</country-code>\
<postal-code-pattern>94043</postal-code-pattern>\
<postal-code-pattern>90211</postal-code-pattern></postal-area>\
</parent_node>"
doc_good = parseString(xml1)
self.assertEquals(doc.toxml(), doc_good.toxml())
def do_call_exit(self):
if d.sessionProperties["persistent"]:
mode = "suspend"
else:
mode = "logout"
document = Document()
rootNode = document.createElement('logout')
rootNode.setAttribute("mode", mode)
document.appendChild(rootNode)
url = "%s/logout.php"%(self.base_url)
request = urllib2.Request(url)
request.add_header("Content-type", "text/xml; charset=UTF-8")
request.add_data(document.toxml())
try:
url = self.urlOpener.open(request)
except urllib2.HTTPError, exc:
if exc.code == 500:
Logger.warn("Service failurek")
return False
Logger.debug("HTTP request return code %d (%s)" % (exc.code, exc.msg))
Logger.debug(" * return: %s"%(str(exc.read())))
return False
def getUpdates():
cache = apt.Cache()
cache.upgrade(dist_upgrade=True)
updates = cache.get_changes()
doc = Document()
host = doc.createElement("host")
host.setAttribute("name", getfqdn())
doc.appendChild(host)
for update in updates:
u = doc.createElement("package")
u.setAttribute("name", update.name)
if update.installed:
u.setAttribute("current_version", update.installed.version)
u.setAttribute("new_version", update.candidate.version)
u.setAttribute("source_name", update.candidate.source_name)
try:
origin = update.candidate.origins[0].origin
u.setAttribute("origin", origin)
except IndexError:
pass
if isSecurityUpgrade(update.candidate):
u.setAttribute("is_security", "true")
host.appendChild(u)
return doc.toxml().replace('\n','')
def _build_xml_shopping_cart(request):
"""
constructs the XML representation of the current customer's shopping cart items to POST to
the Google Checkout API
"""
doc = Document()
root = doc.createElement('checkout-shopping-cart')
root.setAttribute('xmlns', 'http://checkout.google.com/schema/2')
doc.appendChild(root)
shopping_cart = doc.createElement('shopping-cart')
root.appendChild(shopping_cart)
items = doc.createElement('items')
shopping_cart.appendChild(items)
cart_items = carts.get_cart_items(request)
for cart_item in cart_items:
item = doc.createElement('item')
items.appendChild(item)
item_name = doc.createElement('item-name')
item_name_text = doc.createTextNode(str(cart_item.name))
item_name.appendChild(item_name_text)
item.appendChild(item_name)
item_description = doc.createElement('item-description')
item_description_text = doc.createTextNode(str(cart_item.name))
item_description.appendChild(item_description_text)
item.appendChild(item_description)
unit_price = doc.createElement('unit-price')
unit_price.setAttribute('currency', 'USD')
unit_price_text = doc.createTextNode(str(cart_item.price))
unit_price.appendChild(unit_price_text)
item.appendChild(unit_price)
quantity = doc.createElement('quantity')
quantity_text = doc.createTextNode(str(cart_item.quantity))
quantity.appendChild(quantity_text)
item.appendChild(quantity)
checkout_flow = doc.createElement('checkout-flow-support')
root.appendChild(checkout_flow)
merchant_flow = doc.createElement('merchant-checkout-flow-support')
checkout_flow.appendChild(merchant_flow)
shipping_methods = doc.createElement('shipping-methods')
merchant_flow.appendChild(shipping_methods)
flat_rate_shipping = doc.createElement('flat-rate-shipping')
flat_rate_shipping.setAttribute('name', 'FedEx Ground')
shipping_methods.appendChild(flat_rate_shipping)
shipping_price = doc.createElement('price')
shipping_price.setAttribute('currency', 'USD')
flat_rate_shipping.appendChild(shipping_price)
shipping_price_text = doc.createTextNode('9.99')
shipping_price.appendChild(shipping_price_text)
return doc.toxml(encoding='utf-8')
