class activelock(_davbase):
"""XML model for an activelock response message."""
lockscope = fields.Model("lockscope")
locktype = fields.Model("locktype")
depth = fields.String(tagname="depth")
owner = fields.XmlNode(tagname="owner", encoding="UTF-8", required=False)
timeout = TimeoutField(required=False)
locktoken = fields.Model("locktoken", required=False)
class results(dexml.Model):
method = fields.String(tagname='method')
response = fields.String(tagname='response',required=False)
token = fields.String(tagname='token',required=False)
file_infos = fields.List(fields.Model(file_info),required=False)
folder_info = fields.Model(folder_info, required=False)
folders = fields.List("folder_info", tagname="folders", required=False)
files = fields.List("file_info", tagname="files", required=False)
class PaymentTypeInformation(dexml.Model):
'''Conjunto de elementos utilizados para especificar con mayor detalle el tipo de operación.'''
service_level = fields.Model(ServiceLevel)
local_instrument = fields.Model(LocalInstrument)
sequence_type = fields.String(tagname="SeqTp")
def __init__(self):
self.service_level = ServiceLevel()
self.local_instrument = LocalInstrument()
self.sequence_type = "OOFF"
class meta:
tagname = "PmtTpInf"
class DirectDebitTransactionInformation(dexml.Model):
"""
Conjunto de elementos utilizados para proporcionar información sobre cada una de las operaciones individuales
incluidas en el mensaje.
"""
payment_identification = fields.Model(PaymentIdentification)
instructed_amount = fields.Model(InstructedAmount)
charge_bearer = fields.String(tagname="ChrgBr")
direct_debit_transaction = fields.Model(DirectDebitTransaction)
debtor_agent = fields.Model(DebtorAgent)
debtor = fields.Model(Debtor)
debtor_account = fields.Model(DebtorAccount)
remittance_information = fields.Model(RemittanceInformation)
def __init__(self):
self.payment_identification = PaymentIdentification()
self.instructed_amount = InstructedAmount()
self.charge_bearer = "SLEV"
self.debtor_agent = DebtorAgent()
self.debtor = Debtor()
self.debtor_account = DebtorAccount()
self.direct_debit_transaction = DirectDebitTransaction()
class meta:
tagname = "DrctDbtTxInf"
class DirectDebitTransaction(dexml.Model):
'''Conjunto de elementos que suministran información específica relativa al mandato de adeudo directo.'''
mandate_related_information = fields.Model(MandateRelatedInformation)
def __init__(self):
self.mandate_related_information = MandateRelatedInformation()
class meta:
tagname = "DrctDbtTx"
class DebtorAccount(dexml.Model):
'''Identificación inequívoca de la cuenta del deudor donde se cargará el adeudo directo (AT-07).'''
identification = fields.Model(Identification)
def __init__(self):
self.identification = Identification()
class meta:
tagname = "DbtrAcct"
class CreditorSchemeIdentification(dexml.Model):
'''Identificación del acreedor'''
identification = fields.Model(Identification_Private)
def __init__(self):
self.identification = Identification_Private()
class meta(object):
tagname = "CdtrSchmeId"
class Identification_Organisation(dexml.Model):
'''Identificación única e inequívoca de la parte'''
organisation_identification = fields.Model(OrganisationIdentification)
def __init__(self):
self.organisation_identification = OrganisationIdentification()
class meta(object):
tagname = "Id"
class Identification_Private(dexml.Model):
'''Identificación única e inequívoca de la parte'''
private_identification = fields.Model(PrivateIdentification)
def __init__(self):
self.private_identification = PrivateIdentification()
class meta(object):
tagname = "Id"
class OrganisationIdentification(dexml.Model):
'''Identificación única e inequívoca de una persona jurídica.'''
other = fields.Model(Other, required=False)
def __init__(self):
self.other = Other()
class meta:
tagname = "OrgId"
class CreditorAgent(dexml.Model):
'''Entidad de crédito donde el acreedor mantiene su cuenta.'''
financial_institution_identification = fields.Model(FinancialInstitutionIdentification)
def __init__(self):
self.financial_institution_identification = FinancialInstitutionIdentification()
class meta:
tagname = "CdtrAgt"
class PrivateIdentification(dexml.Model):
'''Identificación única e inequívoca de la parte'''
other = fields.Model(Other)
def __init__(self):
self.other = Other()
class meta(object):
tagname = "PrvtId"
class CreditorAccount(dexml.Model):
'''Identificación inequívoca de la cuenta del acreedor AT-04.'''
identification = fields.Model(Identification)
def __init__(self):
self.identification = Identification()
class meta:
tagname = "CdtrAcct"
class InitiatingParty(dexml.Model):
'''Parte que presenta el mensaje. En el mensaje de presentación, puede ser el “acreedor” o “el presentador”.'''
name = fields.String(tagname="Nm", required=False)
# identification = fields.String(tagname="Id", required=False)
identification = fields.Model(Identification_Organisation)
def __init__(self):
self.identification = Identification_Organisation()
class meta:
tagname = "InitgPty"
class DebtorAgent(dexml.Model):
"""
Entidad de crédito donde el deudor mantiene su cuenta (AT-13).
"""
financial_institution_identification = fields.Model(FinancialInstitutionIdentification)
def __init__(self):
self.financial_institution_identification = FinancialInstitutionIdentification()
class meta:
tagname = "DbtrAgt"
class PaymentInformation(dexml.Model):
payment_information_identification = fields.String(tagname="PmtInfId")
payment_method = fields.String(tagname="PmtMtd")
payment_type_information = fields.Model(PaymentTypeInformation)
requested_collection_date = fields.String(tagname="ReqdColltnDt")
creditor = fields.Model(Creditor)
creditor_account = fields.Model(CreditorAccount)
creditor_agent = fields.Model(CreditorAgent)
creditor_scheme_identification = fields.Model(CreditorSchemeIdentification)
direct_debit_transaction_information = fields.Model(DirectDebitTransactionInformation)
def __init__(self, payment_id=None):
self.payment_type_information = PaymentTypeInformation()
if not payment_id:
self.payment_information_identification = generated_id(35)
self.requested_collection_date = iso_date()
self.creditor = Creditor()
self.creditor_account = CreditorAccount()
self.creditor_agent = CreditorAgent()
self.direct_debit_transaction_information = DirectDebitTransactionInformation()
self.creditor_scheme_identification = CreditorSchemeIdentification()
self.payment_method = "DD"
def render(self, **kwargs):
self.payment_information_identification = clean_string(self.payment_information_identification, 35)
self.requested_collection_date = clean_string(self.requested_collection_date, 2)
return super(PaymentInformation, self).render(**kwargs)
class meta:
tagname = "PmtInf"
class CstmrDrctDbtInitn(dexml.Model):
'''Identifica el tipo de mensaje: iniciación de adeudos directos.'''
header = fields.Model(GroupHeader)
# payment_information = fields.Model(PaymentInformation)
payment_information = fields.List(PaymentInformation)
def __init__(self):
self.header = GroupHeader()
# self.payment_information = PaymentInformation()
self.payment_information = list()
class meta:
tagname = "CstmrDrctDbtInitn"
class Document(dexml.Model):
'''Clase base.'''
namespaces = """<Document xmlns="urn:iso:std:iso:20022:tech:xsd:pain.008.001.02" xmlns:asx="http://www.sap.com/abapxml" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">"""
operation = fields.Model(CstmrDrctDbtInitn)
def __init__(self):
self.operation = CstmrDrctDbtInitn()
def render(self, **kwargs):
return super(Document, self).render(**kwargs).replace('<Document>', self.namespaces)
class meta:
tagname = "Document"
class Document(dexml.Model):
"""
Clase base.
"""
namespaces = XML_DOCUMENT_NAMESPACE
operation = fields.Model(CstmrDrctDbtInitn)
def __init__(self):
self.operation = CstmrDrctDbtInitn()
def render(self, **kwargs):
return super(Document, self).render(**kwargs).replace('<Document>', self.namespaces)
class meta:
tagname = "Document"
class GroupHeader(dexml.Model):
'''Conjunto de características compartidas por todas las operaciones incluidas en el mensaje.'''
message_identification = fields.String(tagname='MsgId')
creation_date_time = fields.String(tagname='CreDtTm')
number_of_transactions = fields.String(tagname='NbOfTxs')
control_sum = fields.Float(tagname="CtrlSum", required=False)
initiating_party = fields.Model(InitiatingParty)
def __init__(self):
self.message_identification = generated_id(35)
self.creation_date_time = iso_datetime()
self.initiating_party = InitiatingParty()
self.number_of_transactions = "1"
def render(self, **kwargs):
return super(GroupHeader, self).render(**kwargs)
class meta:
tagname = "GrpHdr"
class MainModel(dexml.Model):
"""Basis for main models. Manages automatically the generation timestamp.
Version "number" and optionnal software information are still to provide."""
version = fields.String()
generated = fields.String() # Could be a date object at some point
software_used = fields.Model(Software, required=False)
def __init__(self,**kwds):
super(MainModel, self).__init__(**kwds)
self.version = "0.3"
self.generated = datetime.datetime.now().isoformat() # warning: no TZ info here
def exportToFile(self, filename, pretty_print=False):
out_str = self.render(encoding="utf-8") # no pretty=pretty_print here, done by lxml
if pretty_print:
# lxml pretty print should be way faster than the minidom one used in dexml
root = etree.fromstring(out_str)
out_str = etree.tostring(root, xml_declaration=True, encoding='utf-8', pretty_print=True)
# print "Output file's content:\n%s" % out_str
with open(os.path.abspath(filename), "wb") as out_f:
out_f.write(out_str)
@classmethod
def loadFromFile(cls, filename):
path_file = os.path.abspath(filename)
if not os.path.isfile(path_file):
err = "Error: '%s' does not exist or is not a file." % filename
print(err)
raise Exception(err)
# Note: parsing a file directly with dexml/minidom is supposedly slower, si I used lxml one,
# but I did not benchmark it.
tree = etree.parse(path_file)
handler = SAX2DOM()
sax.saxify(tree, handler)
dom = handler.document
# In case, you can pass the filename to parse() here to skip lxml
mdl = cls.parse(dom)
return mdl
class pets(dexml.Model):
person = fields.Model()
pets = fields.List("pet",minlength=1)
notes = fields.List(fields.String(tagname="note"),maxlength=2)
rewards = fields.List("reward",tagname="rewards",required=False)
class obj(dexml.Model):
items = fields.Dict(fields.Model(item), key = 'name', unique = True)
class pets(petbase):
person = fields.Model()
pet1 = fields.Model("pet")
pet2 = fields.Model(pet,required=False)
class pets(dexml.Model):
person = fields.Model()
pet1 = fields.Model("pet")
pet2 = fields.Model(pet,required=False)
pet3 = fields.Model((None,pet),required=False)
vet = fields.Model((None,"Vet"),required=False)
class lockinfo(_davbase):
"""XML model for a lockinfo response message."""
lockscope = fields.Model("lockscope")
locktype = fields.Model("locktype")
owner = fields.XmlNode(tagname="owner", encoding="UTF-8")
class lockentry(_davbase):
"""XML model for a lockentry response message."""
lockscope = fields.Model("lockscope")
locktype = fields.Model("locktype")
class B(dexml.Model):
class meta:
namespace='http://yyy'
b = fields.Model(A)
class Whoopsie(dexml.Model):
value = fields.Model("UndefinedModel")
class obj(dexml.Model):
fs = fields.List(fields.Model(self.F, tagname="FF"), tagname="L")
