diff --git a/index.js b/index.js index 0094246..ab61958 100644 --- a/index.js +++ b/index.js @@ -1,14 +1,18 @@ 'use strict'; const Client = require('./lib/Client'); -const Orders = require('./lib/predefinedOrders'); +const OrdersH004 = require('./lib/predefinedOrders/H004'); +const OrdersH005 = require('./lib/predefinedOrders/H005'); const fsKeysStorage = require('./lib/storages/fsKeysStorage'); const tracesStorage = require('./lib/storages/tracesStorage'); const BankLetter = require('./lib/BankLetter'); module.exports = { Client, - Orders, + /** @deprecated Use OrdersH004 or OrdersH005 instead */ + Orders: OrdersH004, + OrdersH004, + OrdersH005, BankLetter, fsKeysStorage, tracesStorage, diff --git a/lib/Client.js b/lib/Client.js index f345e38..abb350b 100644 --- a/lib/Client.js +++ b/lib/Client.js @@ -171,6 +171,7 @@ module.exports = class Client { return { orderData: res.orderData(), + transactionId: res.transactionId(), orderId: res.orderId(), technicalCode: returnedTechnicalCode, @@ -199,37 +200,67 @@ module.exports = class Client { this.tracesStorage.connect().ofType('TRANSFER.ORDER.UPLOAD'); res = await this.ebicsRequest(order); - return [transactionId, orderId]; + const returnedTechnicalCode = res.technicalCode(); + const returnedBusinessCode = res.businessCode(); + + return { + transactionId, + orderId, + + technicalCode: returnedTechnicalCode, + technicalCodeSymbol: res.technicalSymbol(), + technicalCodeShortText: res.technicalShortText( + returnedTechnicalCode, + ), + technicalCodeMeaning: res.technicalMeaning(returnedTechnicalCode), + + businessCode: returnedBusinessCode, + businessCodeSymbol: res.businessSymbol(returnedBusinessCode), + businessCodeShortText: res.businessShortText(returnedBusinessCode), + businessCodeMeaning: res.businessMeaning(returnedBusinessCode), + + // for backwards compatibility with the earlier return value [transactionId, orderId]: + 0: transactionId, + 1: orderId, + [Symbol.iterator]: function* iterator() { + yield transactionId; + yield orderId; + }, + }; } ebicsRequest(order) { return new Promise(async (resolve, reject) => { const { version } = order; const keys = await this.keys(); - const r = signer + const unsignedXml = (await serializer.use(order, this)).toXML(); + const signedXml = signer .version(version) - .sign((await serializer.use(order, this)).toXML(), keys.x()); + .sign(unsignedXml, keys.x()); if (this.tracesStorage) this.tracesStorage - .label(`REQUEST.${order.orderDetails.OrderType}`) - .data(r) + .label(`REQUEST.${order.orderDetails.AdminOrderType || order.orderDetails.OrderType}`) + .data(signedXml) .persist(); rock({ method: 'POST', url: this.url, - body: r, + body: signedXml, headers: { 'content-type': 'text/xml;charset=UTF-8' }, }, (err, res, data) => { - if (err) reject(err); + if (err) { + reject(err); + return; + } const ebicsResponse = response.version(version)(data.toString('utf-8'), keys); if (this.tracesStorage) this.tracesStorage - .label(`RESPONSE.${order.orderDetails.OrderType}`) + .label(`RESPONSE.${order.orderDetails.AdminOrderType || order.orderDetails.OrderType}`) .connect() .data(ebicsResponse.toXML()) .persist(); diff --git a/lib/keymanagers/Key.js b/lib/keymanagers/Key.js index 1fbb745..a13a7b1 100644 --- a/lib/keymanagers/Key.js +++ b/lib/keymanagers/Key.js @@ -7,43 +7,51 @@ const { privateKeyToPem, publicKeyFromPem, privateKeyFromPem, + setRsaPublicKey, + createCertificate, + certificateToPem, + certificateFromPem, + }, + md: { + sha256, }, jsbn: { BigInteger, }, } = require('node-forge'); +const { X509Certificate } = require('crypto'); const getKeyType = (str) => { - const matches = str.match(/(PRIVATE|PUBLIC) KEY/); + const matches = str.match(/BEGIN (?:RSA )?(PRIVATE|PUBLIC|CERTIFICATE)/); if (!matches) return null; return matches[1].toLowerCase(); }; -const keyFromPem = (pem) => { - const type = getKeyType(pem); - const isPublic = type === 'public'; - const key = isPublic ? publicKeyFromPem(pem) : privateKeyFromPem(pem); - - return { - isPublic, - key, - }; -}; - -/** - * Creates a public key from modulus and exponent - * @param {Buffer} mod - the modulus - * @param {Buffer} exp - the exponent - */ -const keyFromModAndExp = (mod, exp) => { - const bnMod = new BigInteger(mod.toString('hex'), 16); - const bnExp = new BigInteger(exp.toString('hex'), 16); - - return { - key: rsa.setPublicKey(bnMod, bnExp), - isPublic: true, - }; +const certificateFromPrivateKey = (privateKey) => { + const certificate = createCertificate(); + certificate.publicKey = setRsaPublicKey(privateKey.n, privateKey.e); + certificate.validity.notBefore = new Date('2000-01-01'); + certificate.validity.notAfter = new Date('9999-12-31'); + certificate.setIssuer([ + { + shortName: 'CN', value: 'ebics.example.com', + }, + ]); + certificate.subject = certificate.issuer; + certificate.setExtensions([ + { + name: 'keyUsage', + keyCertSign: true, + digitalSignature: true, + nonRepudiation: true, + keyEncipherment: true, + dataEncipherment: true, + }, + ]); + certificate.sign(privateKey, sha256.create()); + + return certificate; }; module.exports = class Key { @@ -54,32 +62,23 @@ module.exports = class Key { if (!pem && !mod && !exp) { const keyPair = rsa.generateKeyPair(size); - this.keyIsPublic = false; + this.type = 'private'; this.privateKey = keyPair.privateKey; this.publicKey = keyPair.publicKey; + this.certificate = certificateFromPrivateKey(keyPair.privateKey); return; } // new key from pem string if (pem) { - const { key, isPublic } = keyFromPem(pem); - - this.keyIsPublic = isPublic; - this.privateKey = isPublic ? null : key; - this.publicKey = isPublic ? key : null; - + this.readFromPem(pem); return; } // new key from mod and exp if (mod && exp) { - const { key, isPublic } = keyFromModAndExp(mod, exp); - - this.keyIsPublic = isPublic; - this.privateKey = isPublic ? null : key; - this.publicKey = isPublic ? key : null; - + this.readFromModAndExp(mod, exp); // only used for H004 return; } @@ -87,6 +86,44 @@ module.exports = class Key { throw new Error(`Can not create key without ${!mod ? 'modulus' : 'exponent'}.`); } + readFromPem(pem) { + this.type = getKeyType(pem); + switch (this.type) { + case 'public': + this.publicKey = publicKeyFromPem(pem); + this.privateKey = null; + this.certificate = null; + break; + case 'private': + this.privateKey = privateKeyFromPem(pem); + this.publicKey = setRsaPublicKey(this.privateKey.n, this.privateKey.e); + this.certificate = certificateFromPrivateKey(this.privateKey); + break; + case 'certificate': + this.privateKey = null; + this.certificate = certificateFromPem(pem); + this.publicKey = this.certificate.publicKey; + break; + default: + throw new Error(`Unknown key type: ${this.type}`); + } + } + + /** + * Creates a public key from modulus and exponent + * @param {Buffer} mod - the modulus + * @param {Buffer} exp - the exponent + */ + readFromModAndExp(mod, exp) { + const bnMod = new BigInteger(mod.toString('hex'), 16); + const bnExp = new BigInteger(exp.toString('hex'), 16); + + this.type = 'public'; + this.publicKey = rsa.setPublicKey(bnMod, bnExp); + this.privateKey = null; + this.certificate = null; + } + static generate(size = 2048) { return new Key({ size }); } @@ -96,32 +133,31 @@ module.exports = class Key { } n(to = 'buff') { - const key = this.keyIsPublic ? this.publicKey : this.privateKey; + const key = this.privateKey || this.publicKey; const keyN = Buffer.from(key.n.toByteArray()); return to === 'hex' ? keyN.toString('hex', 1) : keyN; } e(to = 'buff') { - const key = this.keyIsPublic ? this.publicKey : this.privateKey; + const key = this.privateKey || this.publicKey; const eKey = Buffer.from(key.e.toByteArray()); return to === 'hex' ? eKey.toString('hex') : eKey; } d() { - if (this.keyIsPublic) + if (!this.privateKey) throw new Error('Can not get d component out of public key.'); return Buffer.from(this.privateKey.d.toByteArray()); } - isPrivate() { - return !this.keyIsPublic; - } + certificateBase64() { + if (!this.certificate) + throw new Error('Certificate is not available.'); - isPublic() { - return this.keyIsPublic; + return new X509Certificate(certificateToPem(this.certificate)).raw.toString('base64'); } // eslint-disable-next-line class-methods-use-this @@ -133,6 +169,15 @@ module.exports = class Key { } toPem() { - return this.keyIsPublic ? publicKeyToPem(this.publicKey) : privateKeyToPem(this.privateKey); + if (this.privateKey) + return privateKeyToPem(this.privateKey); + + if (this.certificate) + return certificateToPem(this.certificate); + + if (this.publicKey) + return publicKeyToPem(this.publicKey); + + throw new Error('No key found'); } }; diff --git a/lib/keymanagers/defaultKeyEncryptor.js b/lib/keymanagers/defaultKeyEncryptor.js index f80d2d3..94d9975 100644 --- a/lib/keymanagers/defaultKeyEncryptor.js +++ b/lib/keymanagers/defaultKeyEncryptor.js @@ -5,5 +5,5 @@ const { encrypt, decrypt } = require('../crypto/encryptDecrypt'); module.exports = ({ passphrase, iv, algorithm = 'aes-256-cbc' }) => ({ encrypt: data => encrypt(data, algorithm, passphrase, iv), - decrypt: data => decrypt(data, algorithm, passphrase), + decrypt: data => decrypt(data, algorithm, passphrase, iv), }); diff --git a/lib/middleware/response.js b/lib/middleware/response.js index 81eaead..58d3ea8 100644 --- a/lib/middleware/response.js +++ b/lib/middleware/response.js @@ -1,11 +1,13 @@ 'use strict'; const H004Response = require('../orders/H004/response'); +const H005Response = require('../orders/H005/response'); module.exports = { version(v) { if (v.toUpperCase() === 'H004') return H004Response; - + if (v.toUpperCase() === 'H005') return H005Response; + throw Error('Error from middleware/response.js: Invalid version number'); }, }; diff --git a/lib/middleware/serializer.js b/lib/middleware/serializer.js index 1cb38a1..0345741 100644 --- a/lib/middleware/serializer.js +++ b/lib/middleware/serializer.js @@ -1,12 +1,14 @@ 'use strict'; const H004Serializer = require('../orders/H004/serializer'); +const H005Serializer = require('../orders/H005/serializer'); module.exports = { use(order, client) { const { version } = order; if (version.toUpperCase() === 'H004') return H004Serializer.use(order, client); + if (version.toUpperCase() === 'H005') return H005Serializer.use(order, client); throw Error('Error middleware/serializer.js: Invalid version number'); }, diff --git a/lib/middleware/signer.js b/lib/middleware/signer.js index 8c67038..e0e13e4 100644 --- a/lib/middleware/signer.js +++ b/lib/middleware/signer.js @@ -1,10 +1,12 @@ 'use strict'; const H004Signer = require('../orders/H004/signer'); +const H005Signer = require('../orders/H005/signer'); module.exports = { version(v) { if (v.toUpperCase() === 'H004') return H004Signer; + if (v.toUpperCase() === 'H005') return H005Signer; throw Error('Error from middleware/signer.js: Invalid version number'); }, diff --git a/lib/orders/H005/errors.js b/lib/orders/H005/errors.js new file mode 100644 index 0000000..8a55570 --- /dev/null +++ b/lib/orders/H005/errors.js @@ -0,0 +1,122 @@ +'use strict'; + +const h004 = require('../H004/errors'); +const h004t = h004.technical; +const h004b = h004.business; + +const errors = { + technical: { + '000000': h004t['000000'], + '011000': h004t['011000'], + '011001': h004t['011001'], + '011101': h004t['011101'], + '031001': h004t['031001'], + '061001': h004t['061001'], + '061011': h004t['061011'], + '061002': h004t['061002'], + '061099': h004t['061099'], + '061101': h004t['061101'], + '091002': { + symbol: 'EBICS_INVALID_USER_OR_USER_STATE', + short_text: 'Subscriber unknown or subscriber state inadmissible', + meaning: 'Either the initiating party is not known to the bank system or the subscriber state that is stored in the bank of the initiating party is inadmissible with regard to the administrative order type or rather the combination of BTF identifiers.', + }, + '091003': h004t['091003'], + '091004': { + symbol: 'EBICS_INVALID_USER_STATE', + short_text: 'Subscriber state unknown', + meaning: 'The subscriber state of the initiating party that is stored in the bank system is inadmissible with regard to the administrative order type or rather the combination of BTF identifiers', + }, + '091005': { + symbol: 'EBICS_INVALID_ORDER_IDENTIFIER', + short_text: 'Order type or BTF parameter combination inadmissible', + meaning: 'The administrative order type or rather the combination of BTF identifiers are unknown or not approved for use with EBICS', + }, + '091006': { + symbol: 'EBICS_UNSUPPORTED_ORDER_IDENTIFIER', + short_text: 'Order type or BTF parameter combination not supported', + meaning: 'The selected administrative order type or rather the combination of BTF identifiers are optional with EBICS and is not supported by the financial institution', + }, + '091007': { + symbol: 'EBICS_DISTRIBUTED_SIGNATURE_AUTHORISATION_FAILED', + short_text: 'Subscriber possesses no authorisation of signature for the referenced order in the EDS administration (Request recent signature folder)', + meaning: 'Retrieve recent signature folder with permissible orders of order type HVU (or HVZ, respectively)', + }, + '091008': h004t['091008'], + '091009': { + symbol: 'EBICS_SEGMENT_SIZE_EXCEEDED', + short_text: 'Segment size exceeded', + meaning: 'The specified size of an upload order data segment (in the case of H005: 1 MB) has been exceeded', + }, + '091010': h004t['091010'], + '091011': h004t['091011'], + '091101': h004t['091101'], + '091102': h004t['091102'], + '091103': h004t['091103'], + '091104': h004t['091104'], + '091112': h004t['091112'], + '091113': { + symbol: 'EBICS_INVALID_REQUEST_CONTENT', + short_text: 'Message content semantically not compliant to EBICS', + meaning: 'The received message complies syntactically EBICS XML schema, but not semantically to the EBICS guidelines', + }, + '091117': h004t['091117'], + '091118': h004t['091118'], + '091119': h004t['091119'], + '091120': h004t['091120'], + '091121': undefined, + '091122': { + symbol: 'EBICS_ORDER_ALREADY_EXISTS', + short_text: 'The EBICS order already exists', + meaning: 'The data digest of the transmitted order data is already known on the bank server as order data with the same data digest have been transmitted recently. Note:The transmission of the data digest by the user is mandatory. The use of this data for checks by the bank is optional. The client has to check if he has transmitted the same order twice. Consultation with the bank, if necessary', + }, + }, + business: { + '000000': h004b['000000'], + '011301': h004b['011301'], + '091001': h004b['091001'], + '091002': h004b['091002'], + '090003': { + symbol: 'EBICS_AUTHORISATION_ORDER_IDENTIFIER_FAILED', + short_text: 'The subscriber is not entitled to submit orders of the selected administrative order type or rather the combination of BTF identifiers.', + }, + '090004': h004b['090004'], + '090005': h004b['090005'], + '090006': h004b['090006'], + '091105': h004b['091105'], + '091111': h004b['091111'], + '091114': h004b['091114'], + '091115': { + symbol: 'EBICS_ORDERID_ALREADY_FINAL', + short_text: 'A signature file upload request contains an orderID that references an order with invalid processing state: The signature cannot be assigned to the order, because the order has already been fully authorised or rejected.', + }, + '091116': h004b['091116'], + '091201': h004b['091201'], + '091202': h004b['091202'], + '091203': h004b['091203'], + '091204': h004b['091204'], + '091205': h004b['091205'], + '091206': h004b['091206'], + '091207': undefined, + '091208': h004b['091208'], + '091209': h004b['091209'], + '091210': h004b['091210'], + '091211': h004b['091211'], + '091212': h004b['091212'], + '091213': h004b['091213'], + '091214': h004b['091214'], + '091215': h004b['091215'], + '091216': h004b['091216'], + '091217': h004b['091217'], + '091218': h004b['091218'], + '091219': h004b['091219'], + '091301': h004b['091301'], + '091302': h004b['091302'], + '091303': h004b['091303'], + '091304': h004b['091304'], + '091305': h004b['091305'], + '091306': h004b['091306'], + }, +}; + +module.exports = errors; diff --git a/lib/orders/H005/response.js b/lib/orders/H005/response.js new file mode 100644 index 0000000..e42cf32 --- /dev/null +++ b/lib/orders/H005/response.js @@ -0,0 +1,169 @@ +'use strict'; + +const zlib = require('zlib'); +const crypto = require('crypto'); + +const Crypto = require('../../crypto/Crypto'); + +const { DOMParser, XMLSerializer } = require('@xmldom/xmldom'); +const xpath = require('xpath'); +const errors = require('./errors'); + +const DEFAULT_IV = Buffer.from(Array(16).fill(0, 0, 15)); + +const lastChild = (node) => { + let y = node.lastChild; + + while (y.nodeType !== 1) y = y.previousSibling; + + return y; +}; + +module.exports = (xml, keys) => ({ + keys, + doc: new DOMParser().parseFromString(xml, 'text/xml'), + + isSegmented() { + const select = xpath.useNamespaces({ xmlns: 'urn:org:ebics:H005' }); + const node = select( + '//xmlns:header/xmlns:mutable/xmlns:SegmentNumber', + this.doc, + ); + + return !!node.length; + }, + + isLastSegment() { + const select = xpath.useNamespaces({ xmlns: 'urn:org:ebics:H005' }); + const node = select( + "//xmlns:header/xmlns:mutable/*[@lastSegment='true']", + this.doc, + ); + + return !!node.length; + }, + + orderData() { + const orderDataNode = this.doc.getElementsByTagNameNS( + 'urn:org:ebics:H005', + 'OrderData', + ); + + if (!orderDataNode.length) return Buffer.alloc(0); + + const orderData = orderDataNode[0].textContent; + const decipher = crypto + .createDecipheriv('aes-128-cbc', this.transactionKey(), DEFAULT_IV) + .setAutoPadding(false); + const data = Buffer.from( + decipher.update(orderData, 'base64', 'binary') + + decipher.final('binary'), + 'binary', + ); + + return zlib.inflateSync(data); + }, + + transactionKey() { + const keyNodeText = this.doc.getElementsByTagNameNS( + 'urn:org:ebics:H005', + 'TransactionKey', + )[0].textContent; + return Crypto.privateDecrypt( + this.keys.e(), + Buffer.from(keyNodeText, 'base64'), + ); + }, + + transactionId() { + const select = xpath.useNamespaces({ xmlns: 'urn:org:ebics:H005' }); + const node = select( + '//xmlns:header/xmlns:static/xmlns:TransactionID', + this.doc, + ); + + return node.length ? node[0].textContent : ''; + }, + + orderId() { + const select = xpath.useNamespaces({ xmlns: 'urn:org:ebics:H005' }); + const node = select( + './/xmlns:header/xmlns:mutable/xmlns:OrderID', + this.doc, + ); + + return node.length ? node[0].textContent : ''; + }, + + businessCode() { + const select = xpath.useNamespaces({ xmlns: 'urn:org:ebics:H005' }); + const node = select('//xmlns:body/xmlns:ReturnCode', this.doc); + + return node.length ? node[0].textContent : ''; + }, + + businessSymbol(code) { + return errors.business[code].symbol; + }, + + businessShortText(code) { + return errors.business[code].short_text; + }, + + businessMeaning(code) { + return errors.business[code].meaning; + }, + + technicalCode() { + const select = xpath.useNamespaces({ xmlns: 'urn:org:ebics:H005' }); + const node = select( + '//xmlns:header/xmlns:mutable/xmlns:ReturnCode', + this.doc, + ); + + return node.length ? node[0].textContent : ''; + }, + + technicalSymbol() { + const select = xpath.useNamespaces({ xmlns: 'urn:org:ebics:H005' }); + const node = select( + '//xmlns:header/xmlns:mutable/xmlns:ReportText', + this.doc, + ); + + return node.length ? node[0].textContent : ''; + }, + + technicalShortText(code) { + return errors.technical[code].short_text; + }, + + technicalMeaning(code) { + return errors.technical[code].meaning; + }, + + bankKeys() { + const orderData = this.orderData().toString(); + if (!orderData.length) return {}; + + const doc = new DOMParser().parseFromString(orderData, 'text/xml'); + const select = xpath.useNamespaces({ ds: 'http://www.w3.org/2000/09/xmldsig#' }); + const keyNodes = select('//ds:X509Data', doc); + const bankKeys = {}; + + if (!keyNodes.length) return {}; + + for (let i = 0; i < keyNodes.length; i++) { + const type = xpath.select('.//*[local-name(.)=\'AuthenticationVersion\' or local-name(.)=\'EncryptionVersion\']', keyNodes[i].parentNode)[0].textContent; + const certificateBase64 = select('//ds:X509Certificate', keyNodes[i])[0].textContent.trim(); + const certificate = new crypto.X509Certificate(Buffer.from(certificateBase64, 'base64')); + bankKeys[`bank${type}`] = { pem: certificate.toString() }; + } + + return bankKeys; + }, + + toXML() { + return new XMLSerializer().serializeToString(this.doc); + }, +}); diff --git a/lib/orders/H005/serializer.js b/lib/orders/H005/serializer.js new file mode 100644 index 0000000..17b63b7 --- /dev/null +++ b/lib/orders/H005/serializer.js @@ -0,0 +1,19 @@ +'use strict'; + +const constants = require('../../consts'); + +const iniSerializer = require('./serializers/ini'); +const downloadSerializer = require('./serializers/download'); +const uploadSerializer = require('./serializers/upload'); + +module.exports = { + use(order, client) { + const operation = order.operation.toUpperCase(); + + if (operation === constants.orderOperations.ini) return iniSerializer.use(order, client); + if (operation === constants.orderOperations.download) return downloadSerializer.use(order, client); + if (operation === constants.orderOperations.upload) return uploadSerializer.use(order, client); + + throw Error('Error from orders/orders.js: Wrong order version/type.'); + }, +}; diff --git a/lib/orders/H005/serializers/download.js b/lib/orders/H005/serializers/download.js new file mode 100644 index 0000000..1fbd8be --- /dev/null +++ b/lib/orders/H005/serializers/download.js @@ -0,0 +1,66 @@ +'use strict'; + +const js2xmlparser = require('js2xmlparser'); + +const Crypto = require('../../../crypto/Crypto'); +const genericSerializer = require('./generic'); + +module.exports = { + async use(order, client) { + const keys = await client.keys(); + const ebicsAccount = { + partnerId: client.partnerId, + userId: client.userId, + hostId: client.hostId, + }; + const { orderDetails, transactionId } = order; + const { + rootName, xmlOptions, xmlSchema, receipt, transfer, productString, + } = genericSerializer(client.hostId, transactionId); + + this.productString = productString; + this.rootName = rootName; + this.xmlOptions = xmlOptions; + this.xmlSchema = xmlSchema; + this.receipt = receipt; + this.transfer = transfer; + + if (transactionId) return this.receipt(); + + this.xmlSchema.header = { + '@': { authenticate: true }, + static: { + HostID: ebicsAccount.hostId, + Nonce: Crypto.nonce(), + Timestamp: Crypto.timestamp(), + PartnerID: ebicsAccount.partnerId, + UserID: ebicsAccount.userId, + Product: { + '@': { Language: 'en' }, + '#': productString, + }, + OrderDetails: orderDetails, + BankPubKeyDigests: { + Authentication: { + '@': { Version: 'X002', Algorithm: 'http://www.w3.org/2001/04/xmlenc#sha256' }, + '#': Crypto.digestPublicKey(keys.bankX()), + }, + Encryption: { + '@': { Version: 'E002', Algorithm: 'http://www.w3.org/2001/04/xmlenc#sha256' }, + '#': Crypto.digestPublicKey(keys.bankE()), + }, + }, + SecurityMedium: '0000', + }, + mutable: { + TransactionPhase: 'Initialisation', + }, + }; + + return this; + }, + + toXML() { + return js2xmlparser.parse(this.rootName, this.xmlSchema, this.xmlOptions); + }, +}; diff --git a/lib/orders/H005/serializers/generic.js b/lib/orders/H005/serializers/generic.js new file mode 100644 index 0000000..f5231ac --- /dev/null +++ b/lib/orders/H005/serializers/generic.js @@ -0,0 +1,134 @@ +'use strict'; + +const constants = require('../../../consts'); + +const rootName = 'ebicsRequest'; +const rootAttributes = { + 'xmlns:ds': 'http://www.w3.org/2000/09/xmldsig#', + xmlns: 'urn:org:ebics:H005', + Version: 'H005', + Revision: '1', +}; +const header = {}; +const authSignature = ({ + 'ds:SignedInfo': { + 'ds:CanonicalizationMethod': { + '@': { + Algorithm: + 'http://www.w3.org/TR/2001/REC-xml-c14n-20010315', + }, + }, + 'ds:SignatureMethod': { + '@': { + Algorithm: + 'http://www.w3.org/2001/04/xmldsig-more#rsa-sha256', + }, + }, + 'ds:Reference': { + '@': { URI: "#xpointer(//*[@authenticate='true'])" }, + 'ds:Transforms': { + 'ds:Transform': { + '@': { + Algorithm: + 'http://www.w3.org/TR/2001/REC-xml-c14n-20010315', + }, + }, + }, + 'ds:DigestMethod': { + '@': { + Algorithm: + 'http://www.w3.org/2001/04/xmlenc#sha256', + }, + }, + 'ds:DigestValue': {}, + }, + }, + 'ds:SignatureValue': {}, +}); +const body = {}; + +const xmlOptions = { + declaration: { + include: true, + encoding: 'utf-8', + }, + format: { + doubleQuotes: true, + indent: '', + newline: '', + pretty: true, + }, +}; + +module.exports = (hostId, transactionId) => ({ + // return { + productString: constants.productString, + rootName, + xmlOptions, + xmlSchema: { + '@': rootAttributes, + header, + AuthSignature: authSignature, + body, + }, + + receipt() { + this.xmlSchema = { + '@': rootAttributes, + + header: { + '@': { authenticate: true }, + static: { + HostID: hostId, + TransactionID: transactionId, + }, + mutable: { + TransactionPhase: 'Receipt', + }, + }, + + AuthSignature: authSignature, + + body: { + TransferReceipt: { + '@': { authenticate: true }, + ReceiptCode: 0, + }, + }, + }; + + return this; + }, + + transfer(encryptedOrderData) { + this.xmlSchema = { + '@': rootAttributes, + + header: { + '@': { authenticate: true }, + static: { + HostID: hostId, + TransactionID: transactionId, + }, + mutable: { + TransactionPhase: 'Transfer', + SegmentNumber: { + '@': { lastSegment: true }, + '#': 1, + }, + }, + }, + + AuthSignature: authSignature, + + body: { + DataTransfer: { + OrderData: encryptedOrderData, + }, + }, + }; + + return this; + }, + // }; +}); diff --git a/lib/orders/H005/serializers/ini.js b/lib/orders/H005/serializers/ini.js new file mode 100644 index 0000000..6073810 --- /dev/null +++ b/lib/orders/H005/serializers/ini.js @@ -0,0 +1,138 @@ +'use strict'; + +const zlib = require('zlib'); + +const js2xmlparser = require('js2xmlparser'); + +const Crypto = require('../../../crypto/Crypto'); + +const genericSerializer = require('./generic'); + +const keySignature = (ebicsAccount, key, xmlOptions) => { + const xmlOrderData = { + '@': { + 'xmlns:ds': 'http://www.w3.org/2000/09/xmldsig#', + xmlns: 'http://www.ebics.org/S002', + }, + SignaturePubKeyInfo: { + 'ds:X509Data': { + 'ds:X509Certificate': key.certificateBase64(), + }, + SignatureVersion: 'A006', + }, + PartnerID: ebicsAccount.partnerId, + UserID: ebicsAccount.userId, + }; + + return js2xmlparser.parse('SignaturePubKeyOrderData', xmlOrderData, xmlOptions); +}; +const orderData = (ebicsAccount, keys, xmlOptions) => { + const xmlOrderData = { + '@': { + 'xmlns:ds': 'http://www.w3.org/2000/09/xmldsig#', + xmlns: 'urn:org:ebics:H005', + }, + AuthenticationPubKeyInfo: { + 'ds:X509Data': { + 'ds:X509Certificate': keys.x().certificateBase64(), + }, + AuthenticationVersion: 'X002', + }, + EncryptionPubKeyInfo: { + 'ds:X509Data': { + 'ds:X509Certificate': keys.e().certificateBase64(), + }, + EncryptionVersion: 'E002', + }, + PartnerID: ebicsAccount.partnerId, + UserID: ebicsAccount.userId, + }; + + return js2xmlparser.parse('HIARequestOrderData', xmlOrderData, xmlOptions); +}; +const commonHeader = (ebicsAccount, orderDetails, productString) => ({ + '@': { authenticate: true }, + static: { + HostID: ebicsAccount.hostId, + Nonce: Crypto.nonce(), + Timestamp: Crypto.timestamp(), + PartnerID: ebicsAccount.partnerId, + UserID: ebicsAccount.userId, + Product: { + '@': { Language: 'en' }, + '#': productString, + }, + OrderDetails: orderDetails, + SecurityMedium: '0000', + }, + mutable: {}, +}); +const process = { + INI: { + rootName: 'ebicsUnsecuredRequest', + header: (ebicsAccount, orderDetails, productString) => { + const ch = commonHeader(ebicsAccount, orderDetails, productString); + + delete ch.static.Nonce; + delete ch.static.Timestamp; + + return ch; + }, + body: (ebicsAccount, keys, xmlOptions) => ({ + DataTransfer: { + OrderData: Buffer.from(zlib.deflateSync(keySignature(ebicsAccount, keys.a(), xmlOptions))).toString('base64'), + }, + }), + }, + HIA: { + rootName: 'ebicsUnsecuredRequest', + header: (ebicsAccount, orderDetails, productString) => { + const ch = commonHeader(ebicsAccount, orderDetails, productString); + + delete ch.static.Nonce; + delete ch.static.Timestamp; + + return ch; + }, + body: (ebicsAccount, keys, xmlOptions) => ({ + DataTransfer: { + OrderData: Buffer.from(zlib.deflateSync(orderData(ebicsAccount, keys, xmlOptions))).toString('base64'), + }, + }), + }, + HPB: { + rootName: 'ebicsNoPubKeyDigestsRequest', + header: (ebicsAccount, orderDetails, productString) => commonHeader(ebicsAccount, orderDetails, productString), + body: () => ({}), + }, +}; + +module.exports = { + async use(order, client) { + const keys = await client.keys(); + const { orderDetails, transactionId } = order; + const { xmlOptions, xmlSchema, productString } = genericSerializer(client.host, transactionId); + const orderType = orderDetails.AdminOrderType.toUpperCase(); + const ebicsAccount = { + partnerId: client.partnerId, + userId: client.userId, + hostId: client.hostId, + }; + + this.rootName = process[orderType].rootName; + this.xmlOptions = xmlOptions; + this.xmlSchema = xmlSchema; + + this.xmlSchema.header = process[orderType].header(ebicsAccount, orderDetails, productString); + this.xmlSchema.body = process[orderType].body(ebicsAccount, keys, this.xmlOptions); + + if (orderType !== 'HPB' && Object.prototype.hasOwnProperty.call(this.xmlSchema, 'AuthSignature')) + delete this.xmlSchema.AuthSignature; + + return this; + }, + + toXML() { + return js2xmlparser.parse(this.rootName, this.xmlSchema, this.xmlOptions); + }, +}; diff --git a/lib/orders/H005/serializers/upload.js b/lib/orders/H005/serializers/upload.js new file mode 100644 index 0000000..3811393 --- /dev/null +++ b/lib/orders/H005/serializers/upload.js @@ -0,0 +1,99 @@ +'use strict'; + +const zlib = require('zlib'); +const crypto = require('crypto'); + +const js2xmlparser = require('js2xmlparser'); + +const Crypto = require('../../../crypto/Crypto'); + +const downloadSerializer = require('./download'); + +const transKey = crypto.randomBytes(16); + +const signatureValue = (document, key) => { + const digested = Crypto.digestWithHash(document.replace(/\n|\r/g, '')); + + return Crypto.sign(key, digested); +}; +const orderSignature = (ebicsAccount, document, key, xmlOptions) => { + const xmlObj = { + '@': { + xmlns: 'http://www.ebics.org/S002', + 'xmlns:xsi': 'http://www.w3.org/2001/XMLSchema-instance', + 'xsi:schemaLocation': 'http://www.ebics.org/S002 http://www.ebics.org/S002/ebics_signature.xsd', + }, + OrderSignatureData: { + SignatureVersion: 'A006', + SignatureValue: signatureValue(document, key), + PartnerID: ebicsAccount.partnerId, + UserID: ebicsAccount.userId, + }, + }; + + return js2xmlparser.parse('UserSignatureData', xmlObj, xmlOptions); +}; +const encryptedOrderSignature = (ebicsAccount, document, transactionKey, key, xmlOptions) => { + const dst = zlib.deflateSync(orderSignature(ebicsAccount, document, key, xmlOptions)); + const cipher = crypto.createCipheriv('aes-128-cbc', transactionKey, Buffer.from([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])).setAutoPadding(false); + + return Buffer.concat([cipher.update(Crypto.pad(dst)), cipher.final()]).toString('base64'); +}; +const encryptedOrderData = (document, transactionKey) => { + const dst = zlib.deflateSync(document.replace(/\n|\r/g, '')); + const cipher = crypto.createCipheriv('aes-128-cbc', transactionKey, Buffer.from([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0])).setAutoPadding(false); + + return Buffer.concat([cipher.update(Crypto.pad(dst)), cipher.final()]).toString('base64'); +}; + +module.exports = { + async use(order, client) { + const keys = await client.keys(); + const ebicsAccount = { + partnerId: client.partnerId, + userId: client.userId, + hostId: client.hostId, + }; + const { transactionId, document } = order; + const { + rootName, xmlOptions, xmlSchema, transfer, + } = await downloadSerializer.use(order, client); + + this.rootName = rootName; + this.xmlOptions = xmlOptions; + this.xmlSchema = xmlSchema; + this.transfer = transfer; + + if (transactionId) return this.transfer(encryptedOrderData(document, transKey)); + + this.xmlSchema.header.static.NumSegments = 1; + this.xmlSchema.body = { + DataTransfer: { + DataEncryptionInfo: { + '@': { authenticate: true }, + EncryptionPubKeyDigest: { + '@': { Version: 'E002', Algorithm: 'http://www.w3.org/2001/04/xmlenc#sha256' }, + '#': Crypto.digestPublicKey(keys.bankE()), + }, + TransactionKey: Crypto.publicEncrypt(keys.bankE(), transKey).toString('base64'), + }, + SignatureData: { + '@': { authenticate: true }, + '#': encryptedOrderSignature(ebicsAccount, document, transKey, keys.a(), this.xmlOptions), + }, + DataDigest: { + '@': { + SignatureVersion: 'A006', + }, + '#': crypto.createHash('sha256').update(document.replace(/\n|\r/g, '')).digest('base64').trim(), + }, + }, + }; + + return this; + }, + + toXML() { + return js2xmlparser.parse(this.rootName, this.xmlSchema, this.xmlOptions); + }, +}; diff --git a/lib/orders/H005/signer.js b/lib/orders/H005/signer.js new file mode 100644 index 0000000..221a1da --- /dev/null +++ b/lib/orders/H005/signer.js @@ -0,0 +1,62 @@ +'use strict'; + +// const crypto = require('crypto'); +const Crypto = require('../../crypto/Crypto'); + +const { DOMParser, XMLSerializer } = require('@xmldom/xmldom'); +const xpath = require('xpath'); +const C14n = require('xml-crypto/lib/c14n-canonicalization').C14nCanonicalization; + +const digest = (doc) => { + // get the xml node, where the digested value is supposed to be + const nodeDigestValue = doc.getElementsByTagName('ds:DigestValue')[0]; + + // canonicalize the node that has authenticate='true' attribute + const contentToDigest = xpath + .select("//*[@authenticate='true']", doc) + .map(x => new C14n().process(x)) + .join(''); + + // fix the canonicalization + const fixedContent = contentToDigest.replace( + /xmlns="urn:org:ebics:H005"/g, + 'xmlns="urn:org:ebics:H005" xmlns:ds="http://www.w3.org/2000/09/xmldsig#"', + ); + + if (nodeDigestValue) + nodeDigestValue.textContent = Crypto.digestWithHash(fixedContent) + .toString('base64') + .trim(); + + return doc; +}; + +const sign = (doc, key) => { + const nodeSignatureValue = doc.getElementsByTagName('ds:SignatureValue')[0]; + + if (nodeSignatureValue) { + const select = xpath.useNamespaces({ + ds: 'http://www.w3.org/2000/09/xmldsig#', + }); + const contentToSign = new C14n() + .process(select('//ds:SignedInfo', doc)[0]) + .replace( + 'xmlns:ds="http://www.w3.org/2000/09/xmldsig#"', + 'xmlns="urn:org:ebics:H005" xmlns:ds="http://www.w3.org/2000/09/xmldsig#"', + ); + + nodeSignatureValue.textContent = Crypto.privateSign(key, contentToSign); // this.keys.x().key.sign(contentToSign, 'base64'); + } + + return doc; +}; + +const toXML = doc => new XMLSerializer().serializeToString(doc); + +module.exports = { + sign(data, keyX) { + const doc = new DOMParser().parseFromString(data, 'text/xml'); + + return toXML(sign(digest(doc), keyX)); + }, +}; diff --git a/lib/predefinedOrders/AZV.js b/lib/predefinedOrders/H004/AZV.js similarity index 100% rename from lib/predefinedOrders/AZV.js rename to lib/predefinedOrders/H004/AZV.js diff --git a/lib/predefinedOrders/C52.js b/lib/predefinedOrders/H004/C52.js similarity index 85% rename from lib/predefinedOrders/C52.js rename to lib/predefinedOrders/H004/C52.js index 87c8d22..4ec8a1b 100644 --- a/lib/predefinedOrders/C52.js +++ b/lib/predefinedOrders/H004/C52.js @@ -1,6 +1,6 @@ 'use strict'; -const utils = require('../utils'); +const utils = require('../../utils'); module.exports = (start = null, end = null) => ({ version: 'h004', diff --git a/lib/predefinedOrders/C53.js b/lib/predefinedOrders/H004/C53.js similarity index 85% rename from lib/predefinedOrders/C53.js rename to lib/predefinedOrders/H004/C53.js index 6e6bebe..7bd3f72 100644 --- a/lib/predefinedOrders/C53.js +++ b/lib/predefinedOrders/H004/C53.js @@ -1,6 +1,6 @@ 'use strict'; -const utils = require('../utils'); +const utils = require('../../utils'); module.exports = (start = null, end = null) => ({ version: 'h004', diff --git a/lib/predefinedOrders/CCS.js b/lib/predefinedOrders/H004/CCS.js similarity index 100% rename from lib/predefinedOrders/CCS.js rename to lib/predefinedOrders/H004/CCS.js diff --git a/lib/predefinedOrders/CCT.js b/lib/predefinedOrders/H004/CCT.js similarity index 100% rename from lib/predefinedOrders/CCT.js rename to lib/predefinedOrders/H004/CCT.js diff --git a/lib/predefinedOrders/CD1.js b/lib/predefinedOrders/H004/CD1.js similarity index 100% rename from lib/predefinedOrders/CD1.js rename to lib/predefinedOrders/H004/CD1.js diff --git a/lib/predefinedOrders/CDB.js b/lib/predefinedOrders/H004/CDB.js similarity index 100% rename from lib/predefinedOrders/CDB.js rename to lib/predefinedOrders/H004/CDB.js diff --git a/lib/predefinedOrders/CDD.js b/lib/predefinedOrders/H004/CDD.js similarity index 100% rename from lib/predefinedOrders/CDD.js rename to lib/predefinedOrders/H004/CDD.js diff --git a/lib/predefinedOrders/CDS.js b/lib/predefinedOrders/H004/CDS.js similarity index 100% rename from lib/predefinedOrders/CDS.js rename to lib/predefinedOrders/H004/CDS.js diff --git a/lib/predefinedOrders/DKI.js b/lib/predefinedOrders/H004/DKI.js similarity index 85% rename from lib/predefinedOrders/DKI.js rename to lib/predefinedOrders/H004/DKI.js index c31af27..dfe245f 100644 --- a/lib/predefinedOrders/DKI.js +++ b/lib/predefinedOrders/H004/DKI.js @@ -1,6 +1,6 @@ 'use strict'; -const utils = require('../utils'); +const utils = require('../../utils'); module.exports = (start = null, end = null) => ({ version: 'h004', diff --git a/lib/predefinedOrders/G02.js b/lib/predefinedOrders/H004/G02.js similarity index 85% rename from lib/predefinedOrders/G02.js rename to lib/predefinedOrders/H004/G02.js index 8ae0d65..36102fd 100644 --- a/lib/predefinedOrders/G02.js +++ b/lib/predefinedOrders/H004/G02.js @@ -1,6 +1,6 @@ 'use strict'; -const utils = require('../utils'); +const utils = require('../../utils'); module.exports = (start = null, end = null) => ({ version: 'h004', diff --git a/lib/predefinedOrders/G1R.js b/lib/predefinedOrders/H004/G1R.js similarity index 100% rename from lib/predefinedOrders/G1R.js rename to lib/predefinedOrders/H004/G1R.js diff --git a/lib/predefinedOrders/G1V.js b/lib/predefinedOrders/H004/G1V.js similarity index 100% rename from lib/predefinedOrders/G1V.js rename to lib/predefinedOrders/H004/G1V.js diff --git a/lib/predefinedOrders/G52.js b/lib/predefinedOrders/H004/G52.js similarity index 85% rename from lib/predefinedOrders/G52.js rename to lib/predefinedOrders/H004/G52.js index 249bfa3..5ea01a9 100644 --- a/lib/predefinedOrders/G52.js +++ b/lib/predefinedOrders/H004/G52.js @@ -1,6 +1,6 @@ 'use strict'; -const utils = require('../utils'); +const utils = require('../../utils'); module.exports = (start = null, end = null) => ({ version: 'h004', diff --git a/lib/predefinedOrders/G53.js b/lib/predefinedOrders/H004/G53.js similarity index 85% rename from lib/predefinedOrders/G53.js rename to lib/predefinedOrders/H004/G53.js index ba09297..cce38b9 100644 --- a/lib/predefinedOrders/G53.js +++ b/lib/predefinedOrders/H004/G53.js @@ -1,6 +1,6 @@ 'use strict'; -const utils = require('../utils'); +const utils = require('../../utils'); module.exports = (start = null, end = null) => ({ version: 'h004', diff --git a/lib/predefinedOrders/HAA.js b/lib/predefinedOrders/H004/HAA.js similarity index 100% rename from lib/predefinedOrders/HAA.js rename to lib/predefinedOrders/H004/HAA.js diff --git a/lib/predefinedOrders/HAC.js b/lib/predefinedOrders/H004/HAC.js similarity index 85% rename from lib/predefinedOrders/HAC.js rename to lib/predefinedOrders/H004/HAC.js index 82f8f58..6bf37e9 100644 --- a/lib/predefinedOrders/HAC.js +++ b/lib/predefinedOrders/H004/HAC.js @@ -1,6 +1,6 @@ 'use strict'; -const utils = require('../utils'); +const utils = require('../../utils'); module.exports = (start = null, end = null) => ({ version: 'h004', diff --git a/lib/predefinedOrders/HIA.js b/lib/predefinedOrders/H004/HIA.js similarity index 100% rename from lib/predefinedOrders/HIA.js rename to lib/predefinedOrders/H004/HIA.js diff --git a/lib/predefinedOrders/HKD.js b/lib/predefinedOrders/H004/HKD.js similarity index 100% rename from lib/predefinedOrders/HKD.js rename to lib/predefinedOrders/H004/HKD.js diff --git a/lib/predefinedOrders/HPB.js b/lib/predefinedOrders/H004/HPB.js similarity index 100% rename from lib/predefinedOrders/HPB.js rename to lib/predefinedOrders/H004/HPB.js diff --git a/lib/predefinedOrders/HPD.js b/lib/predefinedOrders/H004/HPD.js similarity index 100% rename from lib/predefinedOrders/HPD.js rename to lib/predefinedOrders/H004/HPD.js diff --git a/lib/predefinedOrders/HTD.js b/lib/predefinedOrders/H004/HTD.js similarity index 100% rename from lib/predefinedOrders/HTD.js rename to lib/predefinedOrders/H004/HTD.js diff --git a/lib/predefinedOrders/INI.js b/lib/predefinedOrders/H004/INI.js similarity index 100% rename from lib/predefinedOrders/INI.js rename to lib/predefinedOrders/H004/INI.js diff --git a/lib/predefinedOrders/PTK.js b/lib/predefinedOrders/H004/PTK.js similarity index 85% rename from lib/predefinedOrders/PTK.js rename to lib/predefinedOrders/H004/PTK.js index a0b7e77..760ce63 100644 --- a/lib/predefinedOrders/PTK.js +++ b/lib/predefinedOrders/H004/PTK.js @@ -1,6 +1,6 @@ 'use strict'; -const utils = require('../utils'); +const utils = require('../../utils'); module.exports = (start = null, end = null) => ({ version: 'h004', diff --git a/lib/predefinedOrders/STA.js b/lib/predefinedOrders/H004/STA.js similarity index 85% rename from lib/predefinedOrders/STA.js rename to lib/predefinedOrders/H004/STA.js index 4eb44e9..fa69bb3 100644 --- a/lib/predefinedOrders/STA.js +++ b/lib/predefinedOrders/H004/STA.js @@ -1,6 +1,6 @@ 'use strict'; -const utils = require('../utils'); +const utils = require('../../utils'); module.exports = (start = null, end = null) => ({ version: 'h004', diff --git a/lib/predefinedOrders/VMK.js b/lib/predefinedOrders/H004/VMK.js similarity index 85% rename from lib/predefinedOrders/VMK.js rename to lib/predefinedOrders/H004/VMK.js index 315af09..e9c65c1 100644 --- a/lib/predefinedOrders/VMK.js +++ b/lib/predefinedOrders/H004/VMK.js @@ -1,6 +1,6 @@ 'use strict'; -const utils = require('../utils'); +const utils = require('../../utils'); module.exports = (start = null, end = null) => ({ version: 'h004', diff --git a/lib/predefinedOrders/XCT.js b/lib/predefinedOrders/H004/XCT.js similarity index 100% rename from lib/predefinedOrders/XCT.js rename to lib/predefinedOrders/H004/XCT.js diff --git a/lib/predefinedOrders/XE3.js b/lib/predefinedOrders/H004/XE3.js similarity index 100% rename from lib/predefinedOrders/XE3.js rename to lib/predefinedOrders/H004/XE3.js diff --git a/lib/predefinedOrders/XG1.js b/lib/predefinedOrders/H004/XG1.js similarity index 100% rename from lib/predefinedOrders/XG1.js rename to lib/predefinedOrders/H004/XG1.js diff --git a/lib/predefinedOrders/Z53.js b/lib/predefinedOrders/H004/Z53.js similarity index 85% rename from lib/predefinedOrders/Z53.js rename to lib/predefinedOrders/H004/Z53.js index d196841..5fe1d03 100644 --- a/lib/predefinedOrders/Z53.js +++ b/lib/predefinedOrders/H004/Z53.js @@ -1,6 +1,6 @@ 'use strict'; -const utils = require('../utils'); +const utils = require('../../utils'); module.exports = (start = null, end = null) => ({ version: 'h004', diff --git a/lib/predefinedOrders/index.js b/lib/predefinedOrders/H004/index.js similarity index 100% rename from lib/predefinedOrders/index.js rename to lib/predefinedOrders/H004/index.js diff --git a/lib/predefinedOrders/H005/DCT.js b/lib/predefinedOrders/H005/DCT.js new file mode 100644 index 0000000..0997834 --- /dev/null +++ b/lib/predefinedOrders/H005/DCT.js @@ -0,0 +1,9 @@ +'use strict'; + +const genericUpload = require('./generic-upload'); + +module.exports = (document, options) => genericUpload(document, { + serviceName: 'DCT', + msgName: 'pain.001', + ...options, +}); diff --git a/lib/predefinedOrders/H005/DDD.js b/lib/predefinedOrders/H005/DDD.js new file mode 100644 index 0000000..faaa843 --- /dev/null +++ b/lib/predefinedOrders/H005/DDD.js @@ -0,0 +1,9 @@ +'use strict'; + +const genericUpload = require('./generic-upload'); + +module.exports = (document, options) => genericUpload(document, { + serviceName: 'DDD', + msgName: 'pain.008', + ...options, +}); diff --git a/lib/predefinedOrders/H005/EOP.js b/lib/predefinedOrders/H005/EOP.js new file mode 100644 index 0000000..1afe348 --- /dev/null +++ b/lib/predefinedOrders/H005/EOP.js @@ -0,0 +1,10 @@ +'use strict'; + +const genericDownload = require('./generic-download'); + +module.exports = options => genericDownload({ + serviceName: 'EOP', + msgName: 'camt.053', + containerType: 'ZIP', + ...options, +}); diff --git a/lib/predefinedOrders/H005/HIA.js b/lib/predefinedOrders/H005/HIA.js new file mode 100644 index 0000000..2919607 --- /dev/null +++ b/lib/predefinedOrders/H005/HIA.js @@ -0,0 +1,7 @@ +'use strict'; + +module.exports = { + version: 'h005', + orderDetails: { AdminOrderType: 'HIA' }, + operation: 'ini', +}; diff --git a/lib/predefinedOrders/H005/HPB.js b/lib/predefinedOrders/H005/HPB.js new file mode 100644 index 0000000..c070d85 --- /dev/null +++ b/lib/predefinedOrders/H005/HPB.js @@ -0,0 +1,7 @@ +'use strict'; + +module.exports = { + version: 'h005', + orderDetails: { AdminOrderType: 'HPB' }, + operation: 'ini', +}; diff --git a/lib/predefinedOrders/H005/INI.js b/lib/predefinedOrders/H005/INI.js new file mode 100644 index 0000000..bb7acb4 --- /dev/null +++ b/lib/predefinedOrders/H005/INI.js @@ -0,0 +1,7 @@ +'use strict'; + +module.exports = { + version: 'h005', + orderDetails: { AdminOrderType: 'INI' }, + operation: 'ini', +}; diff --git a/lib/predefinedOrders/H005/MCT.js b/lib/predefinedOrders/H005/MCT.js new file mode 100644 index 0000000..705cd82 --- /dev/null +++ b/lib/predefinedOrders/H005/MCT.js @@ -0,0 +1,9 @@ +'use strict'; + +const genericUpload = require('./generic-upload'); + +module.exports = (document, options) => genericUpload(document, { + serviceName: 'MCT', + msgName: 'pain.001', + ...options, +}); diff --git a/lib/predefinedOrders/H005/PSR.js b/lib/predefinedOrders/H005/PSR.js new file mode 100644 index 0000000..8d37b23 --- /dev/null +++ b/lib/predefinedOrders/H005/PSR.js @@ -0,0 +1,9 @@ +'use strict'; + +const genericDownload = require('./generic-download'); + +module.exports = options => genericDownload({ + serviceName: 'PSR', + msgName: 'pain.002', + ...options, +}); diff --git a/lib/predefinedOrders/H005/REP.js b/lib/predefinedOrders/H005/REP.js new file mode 100644 index 0000000..17e905b --- /dev/null +++ b/lib/predefinedOrders/H005/REP.js @@ -0,0 +1,10 @@ +'use strict'; + +const genericDownload = require('./generic-download'); + +module.exports = options => genericDownload({ + serviceName: 'REP', + msgName: 'camt.054', + containerType: 'ZIP', + ...options, +}); diff --git a/lib/predefinedOrders/H005/SCT.js b/lib/predefinedOrders/H005/SCT.js new file mode 100644 index 0000000..3c34485 --- /dev/null +++ b/lib/predefinedOrders/H005/SCT.js @@ -0,0 +1,9 @@ +'use strict'; + +const genericUpload = require('./generic-upload'); + +module.exports = (document, options) => genericUpload(document, { + serviceName: 'SCT', + msgName: 'pain.001', + ...options, +}); diff --git a/lib/predefinedOrders/H005/SDD.js b/lib/predefinedOrders/H005/SDD.js new file mode 100644 index 0000000..522ab92 --- /dev/null +++ b/lib/predefinedOrders/H005/SDD.js @@ -0,0 +1,9 @@ +'use strict'; + +const genericUpload = require('./generic-upload'); + +module.exports = (document, options) => genericUpload(document, { + serviceName: 'SDD', + msgName: 'pain.008', + ...options, +}); diff --git a/lib/predefinedOrders/H005/STM.js b/lib/predefinedOrders/H005/STM.js new file mode 100644 index 0000000..b745267 --- /dev/null +++ b/lib/predefinedOrders/H005/STM.js @@ -0,0 +1,10 @@ +'use strict'; + +const genericDownload = require('./generic-download'); + +module.exports = options => genericDownload({ + serviceName: 'STM', + msgName: 'camt.052', + containerType: 'ZIP', + ...options, +}); diff --git a/lib/predefinedOrders/H005/XCT.js b/lib/predefinedOrders/H005/XCT.js new file mode 100644 index 0000000..17c1f47 --- /dev/null +++ b/lib/predefinedOrders/H005/XCT.js @@ -0,0 +1,9 @@ +'use strict'; + +const genericUpload = require('./generic-upload'); + +module.exports = (document, options) => genericUpload(document, { + serviceName: 'XCT', + msgName: 'pain.001', + ...options, +}); diff --git a/lib/predefinedOrders/H005/generic-download.js b/lib/predefinedOrders/H005/generic-download.js new file mode 100644 index 0000000..7b22b5e --- /dev/null +++ b/lib/predefinedOrders/H005/generic-download.js @@ -0,0 +1,36 @@ +'use strict'; + +const utils = require('../../utils'); +const { removeUndefinedProperties } = require('../../utils'); + +module.exports = (options) => { + const order = { + version: 'h005', + orderDetails: { + AdminOrderType: 'BTD', + BTDOrderParams: { + Service: { + ServiceName: options.serviceName, + Scope: options.scope, + ServiceOption: options.serviceOption, + Container: options.containerType ? { + '@': { + containerType: options.containerType, + }, + } : undefined, + MsgName: { + '#': options.msgName, + '@': { + version: options.msgVersion, + variant: options.msgVariant, + format: options.msgFormat, + }, + }, + }, + ...utils.dateRange(options.start, options.end), + }, + }, + operation: 'download', + }; + return removeUndefinedProperties(order); +}; diff --git a/lib/predefinedOrders/H005/generic-upload.js b/lib/predefinedOrders/H005/generic-upload.js new file mode 100644 index 0000000..0d2c8f6 --- /dev/null +++ b/lib/predefinedOrders/H005/generic-upload.js @@ -0,0 +1,36 @@ +'use strict'; + +const { removeUndefinedProperties } = require('../../utils'); + +module.exports = (document, options) => { + const order = { + version: 'h005', + orderDetails: { + AdminOrderType: 'BTU', + BTUOrderParams: { + Service: { + ServiceName: options.serviceName, + Scope: options.scope, + ServiceOption: options.serviceOption, + Container: options.containerType ? { + '@': { + containerType: options.containerType, + }, + } : undefined, + MsgName: { + '#': options.msgName, + '@': { + version: options.msgVersion, + variant: options.msgVariant, + format: options.msgFormat, + }, + }, + }, + }, + }, + operation: 'upload', + document, + }; + + return removeUndefinedProperties(order); +}; diff --git a/lib/predefinedOrders/H005/index.js b/lib/predefinedOrders/H005/index.js new file mode 100644 index 0000000..2c284bb --- /dev/null +++ b/lib/predefinedOrders/H005/index.js @@ -0,0 +1,43 @@ +'use strict'; + +const INI = require('./INI'); +const HIA = require('./HIA'); +const HPB = require('./HPB'); + +const genericUpload = require('./generic-upload'); +const genericDownload = require('./generic-download'); + +const DCT = require('./DCT'); +const DDD = require('./DDD'); +const MCT = require('./MCT'); +const SCT = require('./SCT'); +const SDD = require('./SDD'); +const XCT = require('./XCT'); + +const EOP = require('./EOP'); +const PSR = require('./PSR'); +const REP = require('./REP'); +const STM = require('./STM'); + + +module.exports = { + INI, + HIA, + HPB, + + // Upload transactions + genericUpload, + DCT, + DDD, + MCT, + SCT, + SDD, + XCT, + + // Download transactions + genericDownload, + EOP, + PSR, + REP, + STM, +}; diff --git a/lib/utils.js b/lib/utils.js index 85e7431..c544622 100644 --- a/lib/utils.js +++ b/lib/utils.js @@ -40,7 +40,23 @@ const dateRange = (start, end) => { return {}; }; +const removeUndefinedProperties = (obj) => { + if (Array.isArray(obj)) { + obj.map(item => removeUndefinedProperties(item)); + return obj; + } + + if (obj && typeof obj === 'object') + Object.keys(obj).forEach((key) => { + if (obj[key] === undefined) delete obj[key]; + else if (typeof obj[key] === 'object') removeUndefinedProperties(obj[key]); + }); + + return obj; +}; + module.exports = { dateRange, date, + removeUndefinedProperties, }; diff --git a/package-lock.json b/package-lock.json index 5690e66..8649003 100644 --- a/package-lock.json +++ b/package-lock.json @@ -1,12 +1,12 @@ { "name": "ebics-client", - "version": "4.2.0", + "version": "5.0.0", "lockfileVersion": 3, "requires": true, "packages": { "": { "name": "ebics-client", - "version": "4.2.0", + "version": "5.0.0", "license": "MIT", "dependencies": { "@xmldom/xmldom": "^0.8.10", diff --git a/package.json b/package.json index d621f17..3859233 100644 --- a/package.json +++ b/package.json @@ -3,9 +3,11 @@ "version": "5.0.0", "description": "Node.js ISO 20022 Compliant EBICS Client", "main": "index.js", + "types": "types/index.d.ts", "files": [ "lib/**/*", - "templates/**/*" + "templates/**/*", + "types/**/*" ], "scripts": { "lint": "eslint .", diff --git a/test/create-test-client.js b/test/create-test-client.js new file mode 100644 index 0000000..bb8e6d1 --- /dev/null +++ b/test/create-test-client.js @@ -0,0 +1,15 @@ +'use strict'; + +const { Client, fsKeysStorage } = require('..'); +const path = require('path'); + +module.exports = function createTestClient() { + return new Client({ + url: 'https://iso20022test.credit-suisse.com/ebicsweb/ebicsweb', + partnerId: 'CRS04381', + userId: 'CRS04381', + hostId: 'CRSISOTB', + passphrase: 'test', + keyStorage: fsKeysStorage(path.resolve(__dirname, './support/TEST_KEYS.key')), + }); +}; diff --git a/test/spec/H004.js b/test/spec/H004.js index 8b9ae3a..b8db09a 100644 --- a/test/spec/H004.js +++ b/test/spec/H004.js @@ -8,11 +8,12 @@ const path = require('path'); const fs = require('fs'); const ebics = require('../../'); +const createTestClient = require('../create-test-client'); const xmlLintWasm = require('xmllint-wasm'); const validateXML = (() => { - const xsdDir = path.resolve(__dirname, '../xsd'); + const xsdDir = path.resolve(__dirname, '../xsd/H004'); const schemaPath = path.resolve(xsdDir, 'ebics_H004.xsd'); const schemaDoc = fs.readFileSync(schemaPath, { encoding: 'utf8' }); const preload = fs @@ -40,18 +41,9 @@ const validateXML = (() => { }; })(); -const client = new ebics.Client({ - url: 'https://iso20022test.credit-suisse.com/ebicsweb/ebicsweb', - partnerId: 'CRS04381', - userId: 'CRS04381', - hostId: 'CRSISOTB', - passphrase: 'test', - keyStorage: ebics.fsKeysStorage( - path.resolve(__dirname, '../support/TEST_KEYS.key'), - ), -}); +const client = createTestClient(); -const { Orders } = ebics; +const { OrdersH004: Orders } = ebics; /* upload : diff --git a/test/spec/H005.js b/test/spec/H005.js new file mode 100644 index 0000000..425f2b9 --- /dev/null +++ b/test/spec/H005.js @@ -0,0 +1,91 @@ +'use strict'; + +/* eslint-env node, mocha */ + +const { assert } = require('chai'); + +const path = require('path'); +const fs = require('fs'); + +const ebics = require('../..'); +const createTestClient = require('../create-test-client'); + +const xmlLintWasm = require('xmllint-wasm'); + +const validateXML = (() => { + const xsdDir = path.resolve(__dirname, '../xsd/H005'); + const schemaPath = path.resolve(xsdDir, 'ebics_H005.xsd'); + const schemaDoc = fs.readFileSync(schemaPath, { encoding: 'utf8' }); + const preload = fs + .readdirSync(xsdDir) + .filter(file => file.endsWith('.xsd') && file !== 'ebics_H005.xsd') + .map(file => ({ + fileName: file, + contents: fs.readFileSync(path.join(xsdDir, file), { + encoding: 'utf8', + }), + })); + + return async (str) => { + const results = await xmlLintWasm.validateXML({ + xml: { fileName: 'ebics.xml', contents: str }, + schema: [ + { + fileName: 'ebics_H005.xsd', + contents: schemaDoc, + }, + ], + preload, + }); + return results.valid; + }; +})(); + +const client = createTestClient(); + +const { OrdersH005: Orders } = ebics; + +const uploadBuilder = fn => fn('', undefined); +const dateBuilder = fn => fn({ start: '2018-01-01', end: '2019-01-01' }); + +const fnOrders = { + // upload | document + DCT: uploadBuilder, + DDT: uploadBuilder, + MCT: uploadBuilder, + SCT: uploadBuilder, + SDD: uploadBuilder, + XCT: uploadBuilder, + + // download + EOP: dateBuilder, + PSR: dateBuilder, + REP: dateBuilder, + STM: dateBuilder, +}; + +const getOrderObject = (name, order) => { + if (typeof order === 'object') return order; + if (fnOrders[name]) return fnOrders[name](order); + return null; +}; + +describe('H005 order generation', () => { + // eslint-disable-next-line no-restricted-syntax + for (const [name, orderDefinition] of Object.entries(Orders)) { + const order = getOrderObject(name, orderDefinition); + if (!order) continue; + + let type; + if (order.orderDetails.BTUOrderParams) type = order.orderDetails.BTUOrderParams.Service.ServiceName; + else if (order.orderDetails.BTDOrderParams) type = order.orderDetails.BTDOrderParams.Service.ServiceName; + else type = order.orderDetails.AdminOrderType; + + const { operation } = order; + + it(`[${operation}] ${type} order generation`, async () => { + const signedOrder = await client.signOrder(order); + assert.isTrue(await validateXML(signedOrder)); + }); + } +}); diff --git a/test/unit/BankLetterTest.js b/test/unit/BankLetterTest.js index aac0839..f95a67a 100644 --- a/test/unit/BankLetterTest.js +++ b/test/unit/BankLetterTest.js @@ -3,21 +3,14 @@ /* eslint-env node, mocha */ const { assert } = require('chai'); -const { join, resolve } = require('path'); +const { join } = require('path'); const { readFileSync, mkdirSync, existsSync } = require('fs'); const BankLetter = require('../../lib/BankLetter'); -const ebics = require('../../'); - -const client = new ebics.Client({ - url: 'https://iso20022test.credit-suisse.com/ebicsweb/ebicsweb', - partnerId: 'CRS04381', - userId: 'CRS04381', - hostId: 'CRSISOTB', - passphrase: 'test', - keyStorage: ebics.fsKeysStorage(resolve(__dirname, '../support/TEST_KEYS.key')), -}); +const createTestClient = require('../create-test-client'); + +const client = createTestClient(); const createDir = (where) => { try { diff --git a/test/unit/keys.js b/test/unit/keys.js index 8bf3aac..e6b3677 100644 --- a/test/unit/keys.js +++ b/test/unit/keys.js @@ -16,7 +16,7 @@ describe('Keys management', () => { const newKey = Key.generate(); it('private key', () => { - assert.isTrue(newKey.isPrivate()); + assert.isTrue(newKey.type === 'private'); }); it('that has the right key size', () => { @@ -37,7 +37,7 @@ describe('Keys management', () => { const newKey = new Key({ mod: m, exp: e }); it('and is really public', () => { - assert.isTrue(newKey.isPublic()); + assert.isTrue(newKey.type === 'public'); }); @@ -59,7 +59,7 @@ describe('Keys management', () => { const newKey = new Key({ mod: m, exp: e }); it('and is really public', () => { - assert.isTrue(newKey.isPublic()); + assert.isTrue(newKey.type === 'public'); }); it('and has a propper mod as a string', () => { @@ -78,7 +78,7 @@ describe('Keys management', () => { const newKey = new Key({ pem }); it('and is really public', () => { - assert.isTrue(newKey.isPublic()); + assert.isTrue(newKey.type === 'public'); }); it('and has a propper(the same) pem string', () => { diff --git a/test/unit/middlewares.js b/test/unit/middlewares.js index 1e9bad2..72ade39 100644 --- a/test/unit/middlewares.js +++ b/test/unit/middlewares.js @@ -3,23 +3,15 @@ /* eslint-env node, mocha */ const { assert } = require('chai'); -const { resolve } = require('path'); const response = require('../../lib/middleware/response'); const serializer = require('../../lib/middleware/serializer'); const signer = require('../../lib/middleware/signer'); -const ebics = require('../../'); +const createTestClient = require('../create-test-client'); - -const client = new ebics.Client({ - url: 'https://iso20022test.credit-suisse.com/ebicsweb/ebicsweb', - partnerId: 'CRS04381', - userId: 'CRS04381', - hostId: 'CRSISOTB', - passphrase: 'test', - keyStorage: ebics.fsKeysStorage(resolve(__dirname, '../support/TEST_KEYS.key')), -}); +const client = createTestClient(); +const { OrdersH004: Orders } = require('../../'); describe('Middlewares', () => { @@ -32,9 +24,9 @@ describe('Middlewares', () => { it('should throw with no unsupported protocol version', () => assert.throws(() => signer.version('H003'))); }); describe('Serializer Middleware', () => { - it('should not throw with supported protocol version and ini operation', () => assert.doesNotThrow(() => serializer.use(ebics.Orders.INI, client))); - it('should not throw with supported protocol version and download operation', () => assert.doesNotThrow(() => serializer.use(ebics.Orders.STA('2018-01-01', '2018-02-01'), client))); - it('should not throw with supported protocol version and upload operation', () => assert.doesNotThrow(() => serializer.use(ebics.Orders.AZV(''), client))); + it('should not throw with supported protocol version and ini operation', () => assert.doesNotThrow(() => serializer.use(Orders.INI, client))); + it('should not throw with supported protocol version and download operation', () => assert.doesNotThrow(() => serializer.use(Orders.STA('2018-01-01', '2018-02-01'), client))); + it('should not throw with supported protocol version and upload operation', () => assert.doesNotThrow(() => serializer.use(Orders.AZV(''), client))); it('should throw with no supported protocol version and ', () => assert.throws(() => serializer.use({ version: 'H004', operation: 'unspported' }, client))); it('should throw with no unuspported protocol version', () => assert.throws(() => serializer.use({ version: 'H003' }, client))); }); diff --git a/test/unit/responseParser.js b/test/unit/responseParser.js index 191551d..75c439b 100644 --- a/test/unit/responseParser.js +++ b/test/unit/responseParser.js @@ -3,22 +3,15 @@ /* eslint-env node, mocha */ const { readFileSync } = require('fs'); -const { join, resolve } = require('path'); +const { join } = require('path'); const { assert } = require('chai'); const H004Response = require('../../lib/orders/H004/response'); -const ebics = require('../../'); +const createTestClient = require('../create-test-client'); -const client = new ebics.Client({ - url: 'https://iso20022test.credit-suisse.com/ebicsweb/ebicsweb', - partnerId: 'CRS04381', - userId: 'CRS04381', - hostId: 'CRSISOTB', - passphrase: 'test', - keyStorage: ebics.fsKeysStorage(resolve(__dirname, '../support/TEST_KEYS.key')), -}); +const client = createTestClient(); const buildResponse = (xmlPath) => { const response = H004Response('', {}); diff --git a/test/xsd/ebics_H004.xsd b/test/xsd/H004/ebics_H004.xsd similarity index 100% rename from test/xsd/ebics_H004.xsd rename to test/xsd/H004/ebics_H004.xsd diff --git a/test/xsd/ebics_hev.xsd b/test/xsd/H004/ebics_hev.xsd similarity index 100% rename from test/xsd/ebics_hev.xsd rename to test/xsd/H004/ebics_hev.xsd diff --git a/test/xsd/ebics_keymgmt_request_H004.xsd b/test/xsd/H004/ebics_keymgmt_request_H004.xsd similarity index 100% rename from test/xsd/ebics_keymgmt_request_H004.xsd rename to test/xsd/H004/ebics_keymgmt_request_H004.xsd diff --git a/test/xsd/ebics_keymgmt_response_H004.xsd b/test/xsd/H004/ebics_keymgmt_response_H004.xsd similarity index 100% rename from test/xsd/ebics_keymgmt_response_H004.xsd rename to test/xsd/H004/ebics_keymgmt_response_H004.xsd diff --git a/test/xsd/ebics_orders_H004.xsd b/test/xsd/H004/ebics_orders_H004.xsd similarity index 100% rename from test/xsd/ebics_orders_H004.xsd rename to test/xsd/H004/ebics_orders_H004.xsd diff --git a/test/xsd/ebics_request_H004.xsd b/test/xsd/H004/ebics_request_H004.xsd similarity index 100% rename from test/xsd/ebics_request_H004.xsd rename to test/xsd/H004/ebics_request_H004.xsd diff --git a/test/xsd/ebics_response_H004.xsd b/test/xsd/H004/ebics_response_H004.xsd similarity index 100% rename from test/xsd/ebics_response_H004.xsd rename to test/xsd/H004/ebics_response_H004.xsd diff --git a/test/xsd/ebics_signature.xsd b/test/xsd/H004/ebics_signature.xsd similarity index 100% rename from test/xsd/ebics_signature.xsd rename to test/xsd/H004/ebics_signature.xsd diff --git a/test/xsd/ebics_types_H004.xsd b/test/xsd/H004/ebics_types_H004.xsd similarity index 100% rename from test/xsd/ebics_types_H004.xsd rename to test/xsd/H004/ebics_types_H004.xsd diff --git a/test/xsd/test.xsd b/test/xsd/H004/test.xsd similarity index 100% rename from test/xsd/test.xsd rename to test/xsd/H004/test.xsd diff --git a/test/xsd/xmldsig-core-schema.xsd b/test/xsd/H004/xmldsig-core-schema.xsd similarity index 100% rename from test/xsd/xmldsig-core-schema.xsd rename to test/xsd/H004/xmldsig-core-schema.xsd diff --git a/test/xsd/H005/ebics_H005.xsd b/test/xsd/H005/ebics_H005.xsd new file mode 100644 index 0000000..149bf26 --- /dev/null +++ b/test/xsd/H005/ebics_H005.xsd @@ -0,0 +1,11 @@ + + + + ebics_H005.xsd inkludiert alle Schemadateien des EBICS-Protokolls, um die Eindeutigkeit von Element- und Typnamen im EBCIS Namespace zu erzwingen. + ebics_H005.xsd includes all schema files for the EBICS protocol in order to enforce unique element and type names in the EBICS namespace. + + + + + + diff --git a/test/xsd/H005/ebics_hev.xsd b/test/xsd/H005/ebics_hev.xsd new file mode 100644 index 0000000..8ee8458 --- /dev/null +++ b/test/xsd/H005/ebics_hev.xsd @@ -0,0 +1,135 @@ + + + + ebics_hev.xsd ist das EBICS-Protokollschema entweder für Anfragen oder Rückmeldungen der Bank zu unterstützten EBICS-Versionen. + ebics_hev.xsd is the appropriate EBICS protocol schema either for requests or responses according the EBICS versions supported by a bank. + + + + Datentyp für die Host-ID. + Dataype for Host-ID. + + + + + + + + Datentyp für allgemeine Auftragsarten (Grundtyp). + Datatype for general order types (basic type). + + + + + + + + + Datentyp für Antwortcodes. + Datatype for the return code + + + + + + + + + Datentyp für den Erklärungstext zum Antwortcode. + Datatype for report text with respect to the return code + + + + + + + + Datentyp für eine Versionsnummer + Datatype for a release number + + + + + + + + + Datentyp für Versionsnummer des EBICS-schemas + Datatype for release-number of the EBICS scheme + + + + + + + + + Datentyp für technische Fehler. + Datatype for technical error + + + + + Rückmeldung des Ausführungsstatus mit einer eindeutigen Fehlernummer. + Confirmation of the carried out status with a unique error code. + + + + + Klartext der Rückmeldung des Ausführungsstatus. + Clear text of the response (carried out status). + + + + + + + Datentyp für die Request-Daten + Data type for Request data + + + + + + + + + Datentyp für die Response-Daten + Data type for Request data + + + + + + Von der Bank unterstützte EBICS-Versionen, z.B. 2.4 + EBICS-releases supported by the bank, e.g. 2.4 + + + + + + + der EBICS-Version eindeutig zugeordnete Schema-Version, z.B. H003 + EBICS-scheme-version, e.g. H003, well-defined for EBICS-release-Version + + + + + + + + + + + + Requestdaten + request data + + + + + Responsedaten + response data + + + diff --git a/test/xsd/H005/ebics_keymgmt_request_H005.xsd b/test/xsd/H005/ebics_keymgmt_request_H005.xsd new file mode 100644 index 0000000..cb93d3c --- /dev/null +++ b/test/xsd/H005/ebics_keymgmt_request_H005.xsd @@ -0,0 +1,523 @@ + + + + + ebics_keymgmt_request_H005.xsd ist das EBICS-Protokollschema für Schlüsselmanagement-Anfragen (HIA, HPB, HSA, INI). + + + + XML-Signature. + + + + + + + Datentyp für den statischen EBICS-Header (allgemein). + + + + + Hostname des Banksystems. + + + + + Zufallswert; damit wird die Initialisierungsnachricht des Clients einzigartig; nur anzugeben, falls Authentifikationssignatur vorhanden. + + + + + aktueller Zeitstempel zur Begrenzung der serverseitigen Nonce-Speicherung; nur anzugeben, falls Authentifikationssignatur vorhanden. + + + + + Kunden-ID des serverseitig administrierten Kunden. + + + + + Teilnehmer-ID des serverseitig zu diesem Kunden administrierten Teilnehmers. + + + + + technische User-ID für Multi-User-Systeme. + + + + + Kennung des Kundenprodukts bzw. Herstellerkennung oder Name. + + + + + Auftragsdetails. + + + + + Angabe des Sicherheitsmediums, das der Kunde verwendet. + + + + + + + + Datentyp für OrderDetails im statischen EBICS-Header (allgemein). + + + + + Auftragsart. + + + + + + + Datentyp für Element mit Kennung des Kundenprodukts bzw. Herstellerkennung oder Name. + + + + + + Sprachkennzeichen der Kundenproduktversion (gemäß ISO 639). + + + + + Kennung des Herausgebers des Kundenprodukts bzw. des betreuenden Kreditinstituts. + + + + + + + + Datentyp für den leeren variablen EBICS-Header von Key Managemen Aufträgen. + + + + + + + + Anfragestruktur für ungesicherte Auftragsarten HIA (Authentifikations- und Verschlüsselungsschlüssel senden) und INI (bankfachllichen Schlüssel senden). + + + + + + enthält die technischen Transaktionsdaten. + + + + + + enhält alle festen Headereinträge. + + + + + enthält alle variablen Headereinträge. + + + + + + + + + enthält die Auftragsdaten. + + + + + + + + + Transfer von Auftragsdaten. + + + + + + enthält Auftragsdaten. + + + + + + + + + + + + + + + + + + + + + + Datentyp für den statischen EBICS-Header bei ungesicherten Sendeauftragsarten (Aufträge HIA und INI): kein Nonce, kein Timestamp, keine EU-Datei, keine X001 Authentifizierung, keine Verschlüsselung, keine Digests der öffentlichen Bankschlüssel, Nutzdaten komprimiert + + + + + + + Hostname des Banksystems. + + + + + Zufallswert; damit wird die Initialisierungsnachricht des Clients einzigartig; nicht anzugeben für ebicsUnsecuredRequest. + + + + + aktueller Zeitstempel zur Begrenzung der serverseitigen Nonce-Speicherung; nicht anzugeben für ebicsUnsecuredRequest. + + + + + Kunden-ID des serverseitig administrierten Kunden. + + + + + Teilnehmer-ID des serverseitig zu diesem Kunden administrierten Teilnehmers. + + + + + technische User-ID für Multi-User-Systeme. + + + + + Kennung des Kundenprodukts bzw. Herstellerkennung oder Name. + + + + + Auftragsdetails. + + + + + Angabe des Sicherheitsmediums, das der Kunde verwendet. + + + + + + + + + + Datentyp für OrderDetails im statischen EBICS-Header von ebicsUnsecuredRequest. + + + + + + + Auftragsart. + + + + + + + + + Anfragestruktur für Auftragsarten ohne Übertragung der Digests der öffentlichen Bankschlüssel (HPB Bankschlüssel abholen). + + + + + + enthält die technischen Transaktionsdaten. + + + + + + enhält alle festen Headereinträge. + + + + + enthält alle variablen Headereinträge. + + + + + + + + + Authentifikationssignatur. + + + + + enthält optionale Zertifikate (vorgesehen). + + + + + + + + + X.509-Daten des Teilnehmers. + + + + + + + + + + + + Datentyp für den statischen EBICS-Header bei Aufträgen ohne Übertragung der Digests der Bankschlüssel (Auftrag HBP): keine Digests der öffentlichen Bankschlüssel, keine EU-Datei, keine Nutzdaten, OrderId optional!, Nonce, Timestamp, X001 Authentifizierung, Auftragsattribut DZHNN + + + + + + + Hostname des Banksystems. + + + + + Zufallswert; damit wird die Initialisierungsnachricht des Clients einzigartig. + + + + + aktueller Zeitstempel zur Begrenzung der serverseitigen Nonce-Speicherung. + + + + + Kunden-ID des serverseitig administrierten Kunden. + + + + + Teilnehmer-ID des serverseitig zu diesem Kunden administrierten Teilnehmers. + + + + + technische User-ID für Multi-User-Systeme. + + + + + Kennung des Kundenprodukts bzw. Herstellerkennung oder Name. + + + + + Auftragsdetails. + + + + + Angabe des Sicherheitsmediums, das der Kunde verwendet. + + + + + + + + + + Datentyp für OrderDetails im statischen EBICS-Header von ebicsNoPubKeyDigestsRequest. + + + + + + + Auftragsart. + + + + + + + + + The structure for uploads contains order data and the ESs, but without an authentication signature and data digest of bank keys. + Anfragestruktur für Sendeaufträge mit EU-Datei und Nutzdaten aber ohne Authentifizierungssignatur und Digests der Bankschlüssel. + + + + + + Contains technical transaction data. + enthält die technischen Transaktionsdaten. + + + + + + Contains all fixed header entries. + enhält alle festen Headereinträge. + + + + + Contains all mutable header entries. + enthält alle variablen Headereinträge. + + + + + + + + + Contains the order data and the ESs. + enthält die Auftragsdaten und EUs. + + + + + + + + + Transfer of order data and the ESs. + Transfer von Auftragsdaten und EUs. + + + + + + Contains the ESs. + enthält Signaturdaten (EUs). + + + + + + + + + + + + Contains the order data + enthält Auftragsdaten. + + + + + + + + + + + + + + + + + + + + + + Datentyp für den statischen EBICS-Header für ebicsUnsignedRequest.Datentyp für den statischen EBICS-Header bei Aufträgen ohne Authentifizierungssignatur (Auftrag HSA): keine X001 Authentifizierung, keine Digests der öffentlichen Bankschlüssel, EU-Datei, Nutzdaten, Nonce, Timestamp, OrderId, Auftragsattribut OZNNN + + + + + + + Hostname des Banksystems. + + + + + Zufallswert; damit wird die Initialisierungsnachricht des Clients einzigartig; nicht anzugeben bei ebicsUnsignedRequest. + + + + + aktueller Zeitstempel zur Begrenzung der serverseitigen Nonce-Speicherung; nicht anzugeben bei ebicsUnsignedRequest. + + + + + Kunden-ID des serverseitig administrierten Kunden. + + + + + Teilnehmer-ID des serverseitig zu diesem Kunden administrierten Teilnehmers. + + + + + technische User-ID für Multi-User-Systeme. + + + + + Kennung des Kundenprodukts bzw. Herstellerkennung oder Name. + + + + + Auftragsdetails. + + + + + Angabe des Sicherheitsmediums, das der Kunde verwendet. + + + + + + + + + + Datentyp für OrderDetails im statischen EBICS-Header von ebicsUnsignedRequest. + + + + + + + Auftragsart. + + + + + + + diff --git a/test/xsd/H005/ebics_keymgmt_response_H005.xsd b/test/xsd/H005/ebics_keymgmt_response_H005.xsd new file mode 100644 index 0000000..dfc3390 --- /dev/null +++ b/test/xsd/H005/ebics_keymgmt_response_H005.xsd @@ -0,0 +1,137 @@ + + + + + ebics_keymgmt_response_H005.xsd ist das EBICS-Protokollschema für Schlüsselmanagement-Antwortnachrichten (HIA, HPB, HSA, INI). + + + + XML-Signature. + + + + + + + Electronic Banking Internet Communication Standard des Zentralen Kreditausschusses (ZKA): Multibankfähige Schnittstelle zur internetbasierten Kommunikation. + + + + + + enthält die technischen Transaktionsdaten. + + + + + + enhält alle festen Headereinträge. + + + + + + + + enthält alle variablen Headereinträge. + + + + + + + + + enthält die Auftragsdaten und den fachlichen ReturnCode. + + + + + + Transfer von Auftragsdaten; nur bei Download anzugeben (HPB). + + + + + + Informationen zur Verschlüsselung der Auftragsdaten + + + + + + + + + + + + enthält Auftragsdaten. + + + + + + + + + + + + + + + + Antwortcode für den vorangegangenen Transfer. + + + + + + + + + + + + Zeitstempel der letzten Aktualisierung der Bankparameter; nur in der Initialisierungsphase anzugeben. + + + + + + + + + + + + + + + + + + + Datentyp für den variablen EBICS-Header. + + + + + Auftragsnummer von Sendeaufträgen gemäß DFÜ-Abkommen (used for all key management order types except download order type HPB). + + + + + Rückmeldung des Ausführungsstatus mit einer eindeutigen Fehlernummer. + + + + + Klartext der Rückmeldung des Ausführungsstatus. + + + + + + diff --git a/test/xsd/H005/ebics_orders_H005.xsd b/test/xsd/H005/ebics_orders_H005.xsd new file mode 100644 index 0000000..30db121 --- /dev/null +++ b/test/xsd/H005/ebics_orders_H005.xsd @@ -0,0 +1,2094 @@ + + + + + ebics_orders_H005.xsd contains order-based reference elements and order-based type definitions for EBICS. + ebics_orders_H005.xsd enthält auftragsbezogene Referenzelemente und auftragsbezogene Typdefinitionen für EBICS. + + + + + + + XML-Klartext-Auftragsdaten für neue EBICS-Auftragsarten. + Order data in XML format for new EBICS order types. + + + + + Auftragsdaten für Auftragsart HAA (Antwort: abrufbare Auftragsarten abholen). + Order data for order type HAA (response: receive downloadable order types). + + + + + Auftragsdaten für Auftragsart HCA (Anfrage: Änderung der Teilnehmerschlüssel für Authentifikation und Verschlüsselung). + Order data for order type HCA (request: replace user's keys for authentication and encryption). + + + + + Auftragsdaten für Auftragsart HCS (Anfrage: Schlüsselwechsel aller Schlüssel). + Order data for order type HCS (request: replace all keys). + + + + + Auftragsdaten für Auftragsart HIA (Anfrage: Initialisierung der Teilnehmerschlüssel für Authentifikation und Verschlüsselung). + Order data for order type HIA (request: initialise user's keys for authentication and encryption). + + + + + Order data for order type H3K (request: initialise all three user's keys). + Auftragsdaten für Auftragsart H3K (Anfrage: Initialisierung aller drei Teilnehmerschlüssel). + + + + + Auftragsdaten für Auftragsart HKD (Antwort: Kunden- und Teilnehmerdaten des Kunden abholen). + Order data for order type HKD (response: receive customer-based information on the customer and the customer's users). + + + + Schlüssel zur Identifikation des Kontos. + Key for the identification of the account. + + + + + + + Referenz auf die Konten-Identifikationsschlüssel. + Reference to the account identification keys. + + + + + + + + Auftragsdaten für Auftragsart HPB (Antwort: Transfer der Bankschlüssel). + Order data for order type HPB (response: receive bank's public keys). + + + + + Auftragsdaten für Auftragsart HPD (Antwort: Bankparameter abholen). + Order data for order type HPD (response: receive bank parameters). + + + + + Auftragsdaten für Auftragsart HTD (Antwort: Kunden- und Teilnehmerdaten des Teilnehmers abholen). + Order data for order type HTD (response: receive user-based information on the user's customer and the user herself/himself). + + + + Schlüssel zur Identifikation des Kontos. + Key for the identification of the account. + + + + + + + Referenz auf die Konten-Identifikationsschlüssel. + Reference to the account identification keys. + + + + + + + + Auftragsdaten für Auftragsart HVD (Antwort: VEU-Status abrufen). + Order data for order type HVD (response: receive the status of an order currently stored in the distributed signature processing unit). + + + + + Auftragsdaten für Auftragsart HVS (Anfrage: VEU-Storno). + Order data for order type HVS (request: reject an order currently stored in the distributed signature processing unit). + + + + + Auftragsdaten für Auftragsart HVT (Antwort: VEU-Transaktionsdetails abrufen). + Order data for order type HVT (response: receive transaction details of an order currently stored in the distributed signature processing unit). + + + + + + + + + + Auftragsdaten für Auftragsart HVU (Antwort: VEU-Übersicht abholen). + Order data for order type HVU (response: receive summary of orders currently stored in the distributed signature processing unit). + + + + + Auftragsdaten für Auftragsart HVZ (Antwort: VEU-Übersicht mit Zusatzinformationen abholen). + Order data for order type HVZ (response: receive summary of orders currently stored in the distributed signature processing unit with additional information). + + + + + + XML-Strukturen für bankfachliche Elektronische Unterschriften (EUs). + contains the digital signatures. + + + + + enthält die EU des Kreditinstituts. + contains the digital signatures. + + + + + + zusätzliche Auftragsparameter, die zur Ausführung des Auftrags notwendig sind. + additional order parameters required to execute the order. + + + + + zusätzliche Auftragsparameter für Auftragsart HVD. + additional order parameters for order type HVD. + + + + + zusätzliche Auftragsparameter für Auftragsart HVE. + additional order parameters for order type HVE. + + + + + zusätzliche Auftragsparameter für Auftragsart HVS. + additional order parameters for order type HVS. + + + + + zusätzliche Auftragsparameter für Auftragsart HVT. + additional order parameters for order type HVT. + + + + + zusätzliche Auftragsparameter für Auftragsart HVU. + additional order parameters for order type HVU. + + + + + zusätzliche Auftragsparameter für Auftragsart HVZ. + additional order parameters for order type HVZ. + + + + + zusätzliche Auftragsparameter für Standard-Auftragsarten. + additional order parameters for standard order types. + + + + + + Standard-Requeststruktur für HVx-Aufträge (HVD, HVT, HVE, HVS). + Standard request structure for HVx orders (HVD, HVT, HVE, HVS). + + + + Standard-Requestdaten. + Standard request data. + + + + Kunden-ID des Einreichers des ausgewählten Auftrags. + Customer ID of the presenter of the selected order. + + + + + BTF Service Parameter struktur im Falle von BTU/BTD + Identification of the file format in the case of FUL/FDL + + + + + Auftragsnummer des ausgewählten Auftrags. + Order ID of the selected order. + + + + + + + Marker für Elemente und deren Substrukturen, die authentifiziert werden sollen. + Marker for elements and their substructures that are to be authenticated. + + + + Das zugehörige Element ist mitsamt seinen Unterstrukturen zu authentifizieren. + The element (and its substructures) that belongs to this attribute is to be authenticated. + + + + + + optionales Support-Flag, Default = true. + optional support flag, default = true. + + + + Wird die Funktion unterstützt? + Is this function supported? + + + + + + + EU-Berechtigungsinformationen. + permission information of a user's digital signature. + + + + Unterschriftsberechtigung des Teilnehmers, der unterzeichnet hat. + Authorisation level of the user that signed the order. + + + + + + + + Datentyp für Signaturdaten des Kreditinstituts beim EU-Transfer. + Data type for digital signature data transferred using EBICS. + + + + + bankfachliche Elektronische Unterschrift. + Digital signature (either autorising an order or applied for transportation). + + + + + + + + + + + + + Datentyp für Vorabprüfung (Anfrage). + Data type for pre-validation (request). + + + + Client sendet den Hashwert der Auftragsdaten und alle weiteren Daten, die er im Rahmen der Vorabprüfung zur Verfügung stellen will + + + + Hashwert der zu übertragenden Auftragsdatendatei für die Vorabprüfung. + Hashvalue of the transmitted order data for the prevalidation. + + + + + Kontoangabe zur Kontoberechtigung für diesen Zahlungsverkehrsauftrag bei der Vorabprüfung. + Account information for authorisation checks for the payment order within the prevalidation. + + + + + + + + Datentyp für Kontenberechtigungsdaten zur Vorabprüfung. + Data type for the account authorisation data for the prevalidation. + + + + + + + Summe der Zahlungsverkehrsaufträge dieses Kontos für die Höchstbetragsprüfung der EU. + Total sum of the ordered payments regarding this account in order to check the maximum amount limit of the signature permission grades. + + + + + + + + + Datentyp für den Transfer von Auftragsdaten (Anfrage). + Data type for the transfer of order data (request). + + + + + Transaktionsphase? + + + + Initialisierungsphase: Transfer der Signaturdaten (EUs) und des Transaktionsschlüssels. + Inituialisation phase: Transfer of signatur data (ESs) and transaktion key. + + + + Information zur Verschlüsselung der Signatur- und Auftragsdaten. + Information regarding the encryption of signature and order data. + + + + + + + + + + + + enthält Signaturdaten (EUs). + contains signature data (ESs). + + + + + + + + + + + + Hashwert der Auftragsdaten. + Hashvalue of the order data. + + + + + Additional Information about the order (unstructured, up to 255 characters). + + + + + + Transferphase: Transfer von Auftragsdaten. + Transferphase: Transfer of order data. + + + + enthält Auftragsdaten. + contains order data. + + + + + + + + + + + + + + + + + Datentyp für den Transfer von Auftragsdaten (Antwort). + + + + + Transfer des Sitzungsschlüssels und (optional) der Signaturdaten (EUs); nur in der Initialisierungsphase anzugeben. + Transfer of the session key and (optional) signature data (ESs); to be specified only in the initialisation phase. + + + + Information zur Verschlüsselung der Signatur- und Auftragsdaten. + Information regarding the encryption of signature and order data. + + + + + + + + + + + + enthält Signaturdaten (EUs). + contains signature data (ESs). + + + + + + + + + + + + + enthält Auftragsdaten. + contains order data. + + + + + + + + + + + + + + + Datentyp für den Transfer von Transferquittungen. + Data type for the transfer of transfer receipts. + + + + + Quittierungscode für Auftragsdatentransfer. + Receipt code fpr transfer of order data. + + + + + + + + Datentyp für den Transfer von Antwortcodes. + + + + + Antwortcode für den vorangegangenen Transfer. + response code for the foregoing transfer. + + + + + Zeitstempel der letzten Aktualisierung der Bankparameter. + + + + + + + + Datentyp für Auftragsdaten für Auftragsart HAA (Antwort: abrufbare Auftragsarten abholen). + Data type for order data of order type HAA (Response: Download of available order data). + + + + + Liste von Auftragsarten, für die Daten bereit stehen. + List of order types for which data are available. + + + + + + + + Datentyp für Auftragsdaten für Auftragsart HCA (Anfrage: Änderung der Teilnehmerschlüssel für Authentifikation und Verschlüsselung). + Data type for order data regarding order type HCA (Request: Update of Subscriber's key for authentication and encryption). + + + + + öffentlicher Authentifikationsschlüssel. + public key for authentication. + + + + + öffentlicher Verschlüsselungsschlüssel. + public key for encryption. + + + + + Kunden-ID. + Partner-ID. + + + + + Teilnehmer-ID. + User-ID. + + + + + + + + Datentyp für Auftragsdaten für Auftragsart HCS (Anfrage: Schlüsselwechsel aller Schlüssel). + Data type for order data for order type HCS (Request: Update of all keys). + + + + + öffentlicher Authentifikationsschlüssel. + public key for authentication. + + + + + öffentlicher Verschlüsselungsschlüssel. + public key for encryption. + + + + + + Kunden-ID. + Partner-ID. + + + + + Teilnehmer-ID. + User-ID. + + + + + + + + Datentyp für Auftragsdaten für Auftragsart HIA (Anfrage: Initialisierung der Teilnehmerschlüssel für Authentifikation und Verschlüsselung). + Data type for order data for order type HIA (Request: Initialisation of subcriber keys for authentication and encryption). + + + + + öffentlicher Authentifikationsschlüssel. + public key for authentication. + + + + + öffentlicher Verschlüsselungsschlüssel. + public key for encryption. + + + + + Kunden-ID. + Partner-ID. + + + + + Teilnehmer-ID. + User-ID. + + + + + + + + Datentyp für Auftragsdaten für Auftragsart H3K (Anfrage: Initialisierung aller drei Teilnehmerschlüssel). + Order type for order data H3K (request: initialise all three user's keys). + + + + + Key for electronic Signature + Signaturschlüssel. + + + + + Authentication key + Authentifikationsschlüssel. + + + + + Encryption key + Verschlüsselungsschlüssel. + + + + + PartnerID. + Kunden-ID. + + + + + UserID. + Teilnehmer-ID. + + + + + + + Datentyp für Auftragsdaten für Auftragsart HKD (Antwort: Kunden- und Teilnehmerdaten des Kunden abholen). + Order data for order type HKD (response: receive customer based information on the customer and the customer's user. + + + + + Kundendaten. + Customer data. + + + + + Teilnehmerdaten. + User data. + + + + + + + + Datentyp für Auftragsdaten für Auftragsart HPB (Antwort: Transfer der Bankschlüssel). + Data type for order data for order type HPB (Response: Transfer of bank keys). + + + + + öffentlicher Authentifikationsschlüssel. + public authentication key + + + + + öffentlicher Verschlüsselungsschlüssel. + public encryption key + + + + + öffentlicher EU-Signaturschlüssel. + public ES key. + + + + + Banksystem-ID. + Host-ID. + + + + + + + + Datentyp für Auftragsdaten für Auftragsart HPD (Antwort: Bankparameter abholen). + Data type for order data for order type HPD (Response: Download bank parameters). + + + + + Zugangsparameter. + Access Parameter. + + + + + Protokollparameter. + Protocol Parameter. + + + + + + + Datentyp für HPD-Zugangsparameter. + data type for HPD Access Parameter. + + + + + institutsspezifische IP-Adresse/URL. + individual IP-address/URL of the bank. + + + + + + + Gültigkeitsbeginn für die angegebene URL/IP. + Valid-From-Date of the URL/IP. + + + + + + + + + Institutsbezeichnung. + Name of the bank. + + + + + + + + + + Banksystem-ID. + + + + + + + + Datentyp für HPD-Protokollparameter. + Data type for HPD's parameters regarding the EBICS protocol. + + + + + Spezifikation unterstützter Versionen. + Specification of supported versions.. + + + + + Parameter zur Recovery-Funktion (Wiederaufnahme abgebrochener Übertragungen). + Parameter denoting the recovery function (recovery of aborted transmissions). + + + + + + + + Parameter zur Vorabprüfung (über die Übermittlung der EU hinaus). + Parameter denoting the pre-validation (beyond transmission of signatures). + + + + Optionales Support-Flag, Default = true. + Optional support flag, default = true. + + + + + + + Parameter zum Download von Kunden- und Teilnehmerdaten (Auftragsarten HKD/HTD). + Parameter denoting the download of customer and user data (order types HKD/HTD). + + + + + + + + Parameter zum Abruf von Auftragsarten, zu denen Auftragsdaten verfügbar sind (Auftragsart HAA). + Parameter denoting the reception of order types which provides downloadable order data (order type HAA). + + + + + + + + + + + Datentyp für HPD-Versionsinformationen. + Data type for HPD version information. + + + + + unterstützte EBICS-Protokollversionen (H...). + supported EBICS protocol versions. (H...). + + + + + + + + unterstützte Versionen der Authentifikation (X...). + supported version for authentication (X...). + + + + + + + + unterstützte Versionen der Verschlüsselung (E...). + supported version for encryption (E...). + + + + + + + + unterstützte EU-Versionen (A...). + supported version for ES (A...). + + + + + + + + + + + Datentyp für Auftragsdaten für Auftragsart HTD (Antwort: Kunden- und Teilnehmerdaten des Teilnehmers abholen). + Data type for order data for order type HTD (Response: Download partner- and user data). + + + + + Kundendaten. + Customer data. + + + + + Teilnehmerdaten. + User data. + + + + + + + + Datentyp für Auftragsdaten für Auftragsart HVD (Antwort: VEU-Status abrufen). + Data type for order data for order type HVD (Response: EDS-status). + + + + + Hashwert der Auftragsdaten. + Hash value of the order data. + + + + + Begleitzettel/"Displaydatei" (entspricht der Dateianzeige im Kundenprotokoll gemäß DFÜ-Abkommen). + Accompanying ticket/"display file" (corresponds to the display file of the customer's journal according to the document "DFÜ-Abkommen"). + + + + + Kann die Auftragsdatei im Originalformat abgeholt werden? (HVT mit completeOrderData=true) + Can the order file be downloaded in the original format? (HVT with completeOrderData=true) + + + + + Größe der unkomprimierten Auftragsdaten in Bytes. + Size of the uncompressed order data (byte count). + + + + + Können die Auftragsdetails als XML-Dokument HVTResponseOrderData abgeholt werden? (HVT mit completeOrderData=false) + Can the order details be downloaded as XML document HVTResponseOrderData? (HVT with completeOrderData=false) + + + + + bankfachliche Elektronische Unterschrift des Kreditinstituts über Hashwert und Displaydatei. + Digital Signature issued by the bank, covering the hash value and the accompanying ticket. + + + + + Informationen zu den bisherigen Unterzeichnern. + Information about the already existing signers. + + + + + + + + Datentyp für zusätzliche Auftragsparameter für Auftragsart HVD. + Data type for additional order parameters for order type HVD. + + + + + + + + + Datentyp für zusätzliche Auftragsparameter für Auftragsart HVE. + Data type for additional order parameters for order type HVE. + + + + + + + + + Datentyp für zusätzliche Auftragsparameter für Auftragsart HVS. + Data type for additional order parameters for order type HVS. + + + + + + + + + Datentyp für Auftragsdaten für Auftragsart HVS (Anfrage: VEU-Storno). + Data type for order data for order type HVS (request: EDS cancellation). + + + + + Hashwert der Auftragsdaten des stornierten Auftrags. + Hash value of order data of cancelled order. + + + + + + + + Datentyp für Antwort mit Einzelauftraginfos für Auftragsart HVT (Antwort VEU-Transaktionsdetails abrufen mit completeOrderData="false"). + Data type for a response containing information about single transactions for order type HVT (response: EDS transaction details with completeOrderData="false"). + + + + + Gesamtanzahl der Einzelaufträge für den Auftrag. + Total number of order infos for the order. + + + + + Einzelauftragsinfos. + Particular order content information requested for display matters. + + + + + + + + Datentyp für HVT-Konteninformationen. + Data type for account information regarding order type HVT. + + + + + + + + //MODIFIED - Replaced Element OrderFormat with MsgName// Datentyp für HVT-Auftragsinformationen. + + + + + + kontobezogene Details des Auftrags (Auftraggeber, Empfänger etc.). + account related details of the order (ordering party, receiver etc.). + + + + + Ausführungsdatum. + Execution date. + + + + + + + + + + Betrag. + Amount. + + + + + + + Gutschrift (isCredit = "true") oder Lastschrift (isCredit = "false")? + Credit (isCredit = "true") or debit (isCredit = "false")? + + + + + Währungscode. + Currency code. + + + + + + + + + Textfeld zur weiteren Beschreibung der Transaktion (Verwendungszweck, Auftragsdetails, Kommentar). + text field for additional descriptions regarding the transaction (remittance information, order details, annotations). + + + + + + + Beschreibungstyp. + Description type. + + + + + + Verwendungszweck + remittance information. + + + + + Auftragsdetails + Order details. + + + + + Kommentar + Annotation. + + + + + + + + + + + + + + + Datentyp für HVT-Auftragsflags. + Data type for HVT order flags. + + + + Sollen die Transaktionsdetails als Einzelauftragsinfos (completeOrderData=false) oder als komplette Originaldaten (completeOrderData=true) übertragen werden? (Vorschlag für Default=false) + Are the transaction details so be transmitted as particular order content information requested for display matters or in complete order data file form? (Proposal for Default=false) + + + + + Limit für die zu liefernden Transaktionsdetails, bei completeOrderData=false maximale Anzahl zu liefernder Einzelauftragsinfos, 0 für unbegrenzt (Vorschlag für Default=100). + Limit for the transaction details to be transmitted; if completeOrderData=false, maximum number of details of a particular order; 0 for unlimited number of details (Proposal for Default=100). + + + + + + + + + + Offset vom Anfang der Originalauftragsdatei für die zu liefernden Transaktionsdetails, bei completeOrderData=false bezogen auf laufende Nummer des Einzelauftrags (Vorschlag für Default=0). + Offset position in the original order file which marks the starting point for the transaction details to be transmitted; applies to the sequential number of a particular order if completeOrderData=false (Proposal for Default=0). + + + + + + + + + + + + Datentyp für zusätzliche Auftragsparameter für Auftragsart HVT. + Data type for additional order parameters for order type HVT. + + + + + + spezielle Flags für HVT-Aufträge. + Special order flags for orders of type HVT. + + + + + + + + + + Generische Schlüssel-Wert-Parameter + Generic key-value parameters + + + + + + + + Datentyp für Auftragsdaten für Auftragsart HVU (Antwort: VEU-Übersicht abholen). + Data type for order data for order type HVU (Response: Download EDS overview). + + + + + + + + Auftragsinformationen. + + + + + + + + Datentyp für HVU-Auftragsdetails. + Data type for HVU order details. + + + + + Auftragsart lt. DFÜ-Abkommen des ausgewählten Auftrags. + Type of the order. + + + + + Auftragsnummer lt. DFÜ-Abkommen des ausgewählten Auftrags. + Order number. + + + + + Größe der unkomprimierten Auftragsdaten in Bytes. + Order data size in bytes. + + + + + Informationen zu den Unterschriftsmodalitäten. + Signing information. + + + + + Informationen zu den bisherigen Unterzeichnern. + Information regarding the signer. + + + + + Informationen zum Einreicher. + Information regarding the originator. + + + + + Additional Information about the order (unstructured, up to 255 characters). + Additional Information about the order (unstructured, up to 255 characters). + + + + + + + + Datentyp für zusätzliche Auftragsparameter für Auftragsart HVU. + Data type for additional order parameters for order type HVU. + + + + + Liste von Auftragsarten, für die zur Unterschrift vorliegende Aufträge abgerufen werden sollen; falls nicht angegeben, werden sämtliche für den Teilnehmer unterschriftsfähigen Aufträge abgerufen. + + + + + + + + Datentyp für zusätzliche Auftragsparameter für Auftragsart HVZ. + Data type for additional order parameters for order type HVZ. + + + + + Liste von Auftragsarten, für die zur Unterschrift vorliegende Aufträge abgerufen werden sollen; falls nicht angegeben, werden sämtliche für den Teilnehmer unterschriftsfähigen Aufträge abgerufen. + List of order types that the orders ready to be signed by the requesting user should match; if not specified, a list of all orders ready to be signed by the requesting user is returned. + + + + + + + + Datentyp für Informationen zu den HVU-Unterschriftsmodalitäten. + + + + Ist der Auftrag unterschriftsreif ("true") oder bereits vom Teilnehmer unterschrieben ("false")? + + + + + Anzahl der insgesamt zur Freigabe erforderlichen EUs. + + + + + Anzahl der bereits geleisteten EUs. + + + + + + Datentyp für Informationen zum Ersteller eines HVU-Auftrags. + + + + + Kunden-ID des Einreichers. + + + + + Teilnehmer-ID des Einreichers. + + + + + Name des Einreichers. + + + + + Zeitstempel der Einreichung (d.h. der Übertragung der Auftragsdatei). + + + + + + + + Datentyp für Auftragsdaten für Auftragsart HVZ (Antwort: VEU-Übersicht mit Zusatzinformationen abholen). + Order data for order type HVZ (response: receive summary of orders currently stored in the distributed signature processing unit with additional informations). + + + + + + + + Auftragsinformationen. + Summary of order information. + + + + + + + + Datentyp für HVZ-Auftragsdetails. + + + + + BTF Service Parameter-Struktur des ausgewählten Auftrags. + Type of the order. + + + + + Auftragsnummer lt. DFÜ-Abkommen des ausgewählten Auftrags. + ID number of the order. + + + + + Hashwert der Auftragsdaten. + Hash value of the order data. + + + + + Kann die Auftragsdatei im Originalformat abgeholt werden? (HVT mit completeOrderData=true). + Can the order file be downloaded in the original format? (HVT with completeOrderData=true) + + + + + Größe der unkomprimierten Auftragsdaten in Bytes. + Size of uncompressed order data in Bytes. + + + + + Können die Auftragsdetails als XML-Dokument HVTResponseOrderData abgeholt werden? (HVT mit completeOrderData=false). + Can the order details be downloaded as XML document HVTResponseOrderData? (HVT with completeOrderData=false) + + + + + Zusätzliche Auftragsdetails nur für Zahlungsaufträge. + Order details related to payment orders only. + + + + + Informationen zu den Unterschriftsmodalitäten. + Information regarding the signing modalities of the order. + + + + + Informationen zu den bisherigen Unterzeichnern. + Information regarding the users who already signed the order. + + + + + Informationen zum Einreicher. + Information regarding the originator of the order. + + + + + Additional Information about the order (unstructured, up to 255 characters). + + + + + + + + Standard-Requeststruktur für HVx-Aufträge (HVD, HVT, HVE, HVS). + Standard structure for HVZ OrderDetails related to payment orders + + + + + Anzahl der Zahlungssätze über alle logische Dateien entsprechend Dateianzeige. + Total transaction number for all logical files (from dispay file). + + + + + Summe der Beträge über alle logische Dateien entsprechend Dateianzeige. + Total transaction amount for all logical files (from dispay file). + + + + + + + Nur Gutschriften (isCredit = "true") oder nur Lastschriften (isCredit = "false")? Sonst keine Nutzung des Elements. + + + + + + + + + Auftragswährung (nur bei sortenreinen Zahlungen, sonst keine Angabe). + Order currency (only if identical across all transactions, ship otherwise). + + + + + Informationen aus Dateianzeige der ersten logischen Datei. + Order details from display file for first logical file. + + + + + + Auftraggeber entsprechend Dateianzeige. + Order party information (from display file). + + + + + Erstes Auftraggeberkonto entsprechend Dateianzeige. + First order party account (from display file). + + + + + + + Kontonummer (deutsches Format oder international als IBAN). + Account number (German format or international as IBAN). + + + + + + + Ist die Kontonummer im deutschen Format (international=false) oder im internationalen Format (international=true, IBAN) angegeben? + Account number given in German format (international=false) or in international format (international=true, IBAN)? + + + + + + + + + Kontonummer im freien Format. + Account number in free format. + + + + + + + Formatkennung. + Format type. + + + + + + + + + + + Bankleitzahl (deutsches Format oder international als SWIFT-BIC). + Bank sort code (German format or international as SWIFT-BIC). + + + + + + + Ist die Bankleitzahl im deutschen Format (international=false, BLZ) oder im internationalen Format (international=true, SWIFT-BIC) angegeben? + Bank sort code given in German format (international=false) or in international format (international=true, SWIFT-BIC)? + + + + + nationales Präfix für Bankleitzahlen. + National prefix for bank sort code. + + + + + + + + + Bankleitzahl im freien Format. + Bank sort code in free format. + + + + + + + Formatkennung. + Format type. + + + + + + + + + + + + + + + + + + Datentyp für Informationen zu einem Unterzeichner eines VEU-Auftrags (HVU, HVD). + + + + + Kunden-ID des Unterzeichners. + + + + + Teilnehmer-ID des Unterzeichners. + + + + + Name des Unterzeichners. + + + + + Zeitstempel der Unterzeichnung (d.h. der Übertragung der Unterschrift). + + + + + zusätzliche Informationen zu den Berechtigungen des Teilnehmers, der unterzeichnet hat. + + + + + + + + + + + Datentyp für VEU-Berechtigungsinformationen des Teilnehmers (HKD, HTD). + + + + + Liste von Auftragsarten, für die die Berechtigung des Teilnehmers gültig ist. + List of order types which the user's permission belongs to. + + + + + BTF Service Parameter struktur im Falle von BTU/BTD + Identification of the file format in the case of FUL/FDL + + + + + Verweis auf den Identifikationscode des berechtigten Kontos. + Identification codes of the affected accounts. + + + + + Betragshöchstgrenze, bis zu der die Berechtigung des Teilnehmers gültig ist. + Maximum total amount which the user's permission is valid for. + + + + + + + Unterschriftsklasse, für die der Teilnehmer berechtigt ist; nicht anzugeben bei Download-Auftragsarten. + Authorization level of the user who signed the order; to be omitted for orders of type "download". + + + + + + + Datentyp für VEU-Partnerdaten (HKD, HTD). + Data type for customer data with regard to distributed signatures (order types HKD, HTD). + + + + + Informationen zur Adresse des Kunden. + Information about the customer's adress. + + + + + Informationen zur Kreditinstitutsanbindung des Kunden. + Information about the customer's banking access paramters. + + + + + Informationen zu den Konten des Kunden. + Information about the customer's accounts. + + + + + + + + //MODIFIED//Liste der Auftragsartenbeschränkungen; falls nicht angegeben, gibt es keine Auftragsartenbeschränkungen; falls das Element ohne Service-Element geliefert wird, ist das Konto für keine Auftragsart freigegeben. + List containing the order types which contain this account is restricted to; if omitted, the account is unrestricted; if the list is empty the account is blocked for any order type. + + + + + + + Identifikationscode des Kontos. + + + + + + + + + Informationen zu den Auftragsarten, für die der Kunde berechtigt ist. + Information about order types which the customer is authorised to use. + + + + + + + Datentyp für VEU-Adressinformationen (HKD, HTD). + Data type for address information with regard to distributed signature (order types HKD, HTD). + + + + + Name des Kunden. + Customer's name. + + + + + Straße und Hausnummer. + Street and house number. + + + + + Postleitzahl. + Postal code. + + + + + Stadt. + City. + + + + + Region / Bundesland / Bundesstaat. + Region / province / federal state. + + + + + Land. + Country. + + + + + + + + Datentyp für VEU-Kreditinstitutsinformationen (HKD, HTD). + + + + + Banksystem-ID. + + + + + + + + + Datentyp für VEU-Teilnehmerinformationen (HKD, HTD). + + + + + Teilnehmer-ID. + + + + + + + Status des Teilnehmers. + + + + + + + + + Name des Teilnehmers. + + + + + Informationen zu den Berechtigungen des Teilnehmers. + + + + + + + + Datentyp für VEU-Berechtigungsinformationen zu Auftragsarten (HKD, HTD). + Data type for user permissions with regard to distributed signatures (order types HKD, HTD). + + + + + Administrative EBICS Auftragsart. + + + + + BTF Service Parameter struktur im Falle von BTU/BTD + Identification of the file format in the case of FUL/FDL + + + + + Beschreibung der Auftragsart. + + + + + Anzahl erforderlicher EUs (Default=0). + + + + + + + + Datentyp für zusätzliche Auftragsparameter bei Standard-Auftragsarten. + + + + + Datumsbereich (von-bis). + + + + + + Startdatum (inkl.). + + + + + Enddatum (inkl.). + + + + + + + + + + Attribute zur EBICS-Protokollversion und -revision. + Attributes regarding the protocol version and revision of EBICS. + + + + Version des EBICS-Protokolls (z.B. "H00x"). + Version of the EBICS protocol (e.g. "H00x"). + + + + + Revision des EBICS-Protokolls (z.B. 1). + Revision of the EBICS protocol (e.g. 1). + + + + + + + zusätzliche Auftragsparameter für Auftragsart BTD. + additional order parameters for order type BTD. + + + + + zusätzliche Auftragsparameter für Auftragsart BTU. + additional order parameters for order type BTU. + + + + + Datentyp für BTF Download Parameter + + + + + + + Service name - target system for the further processing of the order + + + + + + + + The file name on the client It can be transmitted optionally + + + + + + + + Datentyp für BTF Upload Parameter + + + + + + + Service name - target system for the further processing of the order + + + + + If not present the order doesn't contain any ES and shall be authorised outside EBICS +If present the order shall be autorised within EBICS: +1. If the attribute VEU is also present the sender desires spooling into the VEU - hence in this case the order is not rejected in the case of not sufficient number of ES +2. If the attribute is not present all necessary ES must be inside the order (else: rejection of the order) + + + + + + + The file name on the client It can be transmitted optionally + + + + + + + + Abstract Type containing all BTF params structures + + + + + Service name - target system for the further processing of the order + + + + + If not present the order doesn't contain any ES and shall be authorised outside EBICS +If present the order shall be autorised within EBICS: +1. If the attribute VEU is also present the sender desires spooling into the VEU - hence in this case the order is not rejected in the case of not sufficient number of ES +2. If the attribute is not present all necessary ES must be inside the order (else: rejection of the order) + + + + + + + + The file name on the client It can be transmitted optionally + + + + + + Datentyp für die Angabe eines (Berichts-) Zeitraums + + + + + + + + + Basis-Datentyp für Kennzeichen mit optionalem Attribut + + + + + + Datentyp für Meldungstyp-String mit optionalen Attributen + + + + + + Variant number of the message type (usable for ISO20022 messages) + + + + + Version number of the message type (usable for ISO20022 messages) + + + + + Encoding format of the message (e.g. XML, ASN1, JSON, PDF) + + + + + + + + + + + + + Basisdatentyp für BTF-Service Parameter Set + + + + + Service Code name: External list specified and maintained by EBICS. Basis is the "SWIFT-list" for the field "description" (SCT, DCT, XCT, SDD, DDD, STM, REP...) plus additional codes needed for further services + + + + + Specifies whose rules have to be taken into account for the service. This means which market / comminity has defined the rules. +If the element is absent a global definition for the service is assumed. +External list specified and maintained by EBICS. In addition the following codes may be used: +2-character ISO country code or a 3-character issuer code (defined by EBICS) + + + + + Service Option Code +Additional option for the service (also depends on used scope) + + + + + Container flag. If present, data is provided/requested in a container format specified in the attribute of the flag + + + + + Name of the message, e.g. pain.001 or mt101 National message names (issued by DK, CFONB or SIC are also allowed) + + + + + + + Type is arestriction of the generic ServiceType, defining the mandatory elements + + + + + + + Service Code name: External list specified and maintained by EBICS. Basis is the "SWIFT-list" for the field "description" (SCT, DCT, XCT, SDD, DDD, STM, REP...) plus additional codes needed for further services + + + + + Specifies whose rules have to be taken into account for the service. This means which market / comminity has defined the rules. +If the element is absent a global definition for the service is assumed. +External list specified and maintained by EBICS. +In addition the following codes may be used: +2-character ISO country code or a 3-character issuer code (defined by EBICS) + + + + + Service Option Code + Additional option for the service (also depends on used scope) + + + + + Container flag. If present, data is provided/requested in a container format specified in the attribute of the flag + + + + + Name of the message, e.g. pain.001 or mt101 National message names (issued by DK, CFONB or SIC are also allowed) + + + + + + + + + Container flag. If present, data is provided/requested in a container format specified in the attribute of the flag + + + + + + Specifies the container type - External Codelist defined by EBICS (starting values: XML, ZIP, SVC) + + + + + + + + Datentyp für BTF Signatur-Flag (ersetzt Orderkennzeichen) + + + + + + If present the sender desires spooling into EBICS distributed signature queue, only "true" is allowed + + + + + + + + Datentyp zur Kennzeichnung von Auftragsartenbeschränkungen + + + + + Service Parameter-Sets von nicht unterstützten BTF-Auftragsarten + + + + + + diff --git a/test/xsd/H005/ebics_request_H005.xsd b/test/xsd/H005/ebics_request_H005.xsd new file mode 100644 index 0000000..dc7ad70 --- /dev/null +++ b/test/xsd/H005/ebics_request_H005.xsd @@ -0,0 +1,349 @@ + + + + + ebics_request_H005.xsd ist das EBICS-Protokollschema für Anfragen. + ebics_request_H005.xsd is the appropriate EBICS protocol schema for standard requests. + + + + + + + Electronic Banking Internet Communication Standard of the EBICS SCRL: Multibankfähige Schnittstelle zur internetbasierten Kommunikation. + Electronic Banking Internet Communication Standard der EBICS SCRL: multi-bank capable interface for internet-based communication. + + + + + + enthält die technischen Transaktionsdaten. + contains the transaction-driven data. + + + + + + enhält alle festen Headereinträge. + contains the static header entries. + + + + + enthält alle variablen Headereinträge. + contains the mutable header entries. + + + + + + + + + + enthält die Auftragsdaten, EU(s) und weitere Nutzdaten. + contains order data, order signature(s) and further data referring to the current order. + + + + + + + + + X.509-Daten des Teilnehmers. + X.509 data of the user. + + + + + Welche Transaktionsphase? + Which transaction phase? + + + + Initialisierungs- und Transferphase. + Initialisation or transfer phase. + + + + Daten zur Vorabprüfung; nur anzugeben in der Initialisierungsphase bei Uploads mit Auftragsattribut OZH (EUs + Auftragsdaten). + Data sent for pre-validation; mandatory for initialisation phase during uploads using order attribute OZH (order signature(s) + order data). + + + + + + + + + + + + Transfer von Signatur- bzw. Auftragsdaten; nur bei Upload anzugeben. + Transfer of signature or order data; mandatory for uploads only. + + + + + + Quittierungsphase nach Download. + Receipt phase after download. + + + + Quittierung des Transfers. + Receipt of transfer. + + + + + + + + + + + + + + + + + + + + + + Datentyp für den statischen EBICS-Header. + Data type for the static EBICS header. + + + + + Hostname des Banksystems. + + + + + Transaktionsphase? + Transaction phase? + + + + Initialisierungsphase. + Initialisation phase. + + + + Zufallswert; damit wird die Initialisierungsnachricht des Clients einzigartig. + Random value, ensures the uniqueness of the client's message during initialisation phase. + + + + + aktueller Zeitstempel zur Begrenzung der serverseitigen Nonce-Speicherung. + current timestamp, used to limit storage space for nonces on the server. + + + + + Kunden-ID des serverseitig administrierten Kunden. + ID of the partner = customer, administered on the server. + + + + + Teilnehmer-ID des serverseitig zu diesem Kunden administrierten Teilnehmers. + ID of the user that is assigned to the given customer, administered on the server. + + + + + technische User-ID für Multi-User-Systeme. + ID of the system for multi-user systems. + + + + + Kennung des Kundenprodukts bzw. Herstellerkennung oder Name. + software ID / manufacturer ID / manufacturer's name of the customer's software package. + + + + + + + Sprachkennzeichen der Kundenproduktversion (gemäß ISO 639). + Language code of the customer's software package according to ISO 639. + + + + + Kennung des Herausgebers des Kundenprodukts bzw. des betreuenden Kreditinstituts. + ID of the manufacturer / financial institute providing support for the customer's software package. + + + + + + + + + Auftragsdetails. + order details. + + + + + Hashwerte der erwarteten öffentlichen Schlüssel (Verschlüsselung, Signatur, Authentifikation) des Kreditinstituts. + Digest values of the expected public keys (authentication, encryption, signature) owned by the financial institute. + + + + + + Hashwert des Authentifikationsschlüssels. + Digest value of the public authentication key. + + + + + + + Version des Authentifikationsverfahrens. + Version of the algorithm used for authentication. + + + + + + + + + Hashwert des Verschlüsselungsschlüssels. + Digest value of the public encryption key. + + + + + + + Version des Verschlüsselungsverfahrens. + Version of the algorithm used for encryption. + + + + + + + + + Hashwert des Signaturschlüssels. + Digest value of the public signature key. + + + + + + + Version des Signaturverfahrens. + Version of the algorithm used for signature creation. + + + + + + + + + + + + Angabe des Sicherheitsmediums, das der Kunde verwendet. + Classification of the security medium used by the customer. + + + + + Gesamtsegmentanzahl für diese Transaktion; nur bei Uploads anzugeben. + Total number of segments for this transaction; mandatory for uploads only. + + + + + + + Transfer- und Quittierungsphase. + Transfer or receipt phase. + + + + eindeutige, technische Transaktions-ID; wird vom Server vergeben. + unique transaction ID, provided by the server. + + + + + + + + + Datentyp für den variablen EBICS-Header. + Data type for the mutable EBICS header. + + + + + Phase, in der sich die Transaktion gerade befindet; wird bei jedem Transaktionsschritt vom Client gesetzt und vom Server übernommen. + Current phase of the transaction; this information is provided by the client for each step of the transaction, and the server adopts the setting. + + + + + enthält die Nummer des aktuellen Segments, welches gerade übertragen oder angefordert wird; nur anzugeben bei TransactionPhase=Transfer. + contains the number of the segment which is currently being transmitted or requested; mandatory for transaction phase 'Transfer' only. + + + + + + + Ist dies das letzte Segment der Übertragung? + Is this segment meant to be the last one regarding this transmission? + + + + + + + + + + + + //MODIFIED - Removed OrderAtribute ELEMENT// Datentyp für Auftragsdetails im statischen EBICS-Header. + Data type for order details stored in the static EBICS header. + + + + + //MODIFIED - Umbenannt von OrderType// Auftragsart. + type code of the order. + + + + + + + + + + Auftragsnummer für Sendeaufträge gemäß DFÜ-Abkommen. + ID of the (upload) order, formatted in accordance with the document "DFÜ-Abkommen". + + + + + + diff --git a/test/xsd/H005/ebics_response_H005.xsd b/test/xsd/H005/ebics_response_H005.xsd new file mode 100644 index 0000000..841286b --- /dev/null +++ b/test/xsd/H005/ebics_response_H005.xsd @@ -0,0 +1,167 @@ + + + + + ebics_response_H005.xsd ist das EBICS-Protokollschema für Antwortnachrichten. + ebics_response_H005.xsd is the appropriate EBICS protocol schema for standard responses. + + + + XML-Signature. + + + + + + + Electronic Banking Internet Communication Standard des Zentralen Kreditausschusses (ZKA): Multibankfähige Schnittstelle zur internetbasierten Kommunikation. + Electronic Banking Internet Communication Standard of the "Zentraler Kreditausschuss (ZKA)": multi-bank capable interface for internet-based communication. + + + + + + enthält die technischen Transaktionsdaten. + contains the transaction-driven data. + + + + + + enhält alle festen Headereinträge. + contains the static header entries. + + + + + enthält alle variablen Headereinträge. + contains the mutable header entries. + + + + + + + + + Authentifikationssignatur. + Authentication signature. + + + + + enthält die Auftragsdaten, EU(s) und weitere Nutzdaten. + contains order data, order signature(s) and further data referring to the current order. + + + + + + Transfer von Auftragsdaten; nur bei Download anzugeben. + Transfer of signature or order data; mandatory for downloads only. + + + + + fachlicher Antwortcode für den vorangegangenen Request. + order-related return code of the previous request. + + + + + + + + + + + + Zeitstempel der letzten Aktualisierung der Bankparameter; nur in der Initialisierungsphase anzugeben. + timestamp indicating the latest update of the bank parameters; may be set during initialisation phase only. + + + + + + + + + + + + + + + + + + + + //TODO - Modify anotation TransactionID// Datentyp für den statischen EBICS-Header. + Data type for the static EBICS header. + + + + + eindeutige, technische Transaktions-ID; wird vom Server vergeben, falls OrderAttribute entweder gleich "OZHNN" oder gleich "DZHNN" ist und falls tatsächlich eine Transaktion erzeugt wurde. + unique transaction ID, provided by the server if and only if the order attribute is set to either "OZHNN" or "DZHNN" and if a transaction has been established actually. + + + + + Gesamtsegmentanzahl für diese Transaktion; nur bei Downloads in der Initialisierungsphase anzugeben. + Total number of segments for this transaction; mandatory for downloads in initialisation phase only. + + + + + + + Datentyp für den variablen EBICS-Header. + Data type for the mutable EBICS header. + + + + + Phase, in der sich die Transaktion gerade befindet; wird bei jedem Transaktionsschritt vom Client gesetzt und vom Server übernommen. + Current phase of the transaction; this information is provided by the client for each step of the transaction, and the server adopts the setting. + + + + + enthält die Nummer des aktuellen Segments, welches gerade übertragen oder angefordert wird; nur anzugeben bei TransactionPhase=Transfer und (bei Download) TransactionPhase=Initialisation. + contains the number of the segment which is currently being transmitted or requested; mandatory for transaction phases 'Transfer' and (for downloads) 'Initialisation' only. + + + + + + + Ist dies das letzte Segment der Übertragung? + + + + + + + + + Auftragsnummer von Sendeaufträgen gemäß DFÜ-Abkommen. + + + + + Rückmeldung des technischen Status mit einer eindeutigen Fehlernummer. + Return code indicating the technical status. + + + + + Klartext der Rückmeldung des technischen Status. + Textual interpretation of the returned technical status code. + + + + + + diff --git a/test/xsd/H005/ebics_signature_S002.xsd b/test/xsd/H005/ebics_signature_S002.xsd new file mode 100644 index 0000000..3127faa --- /dev/null +++ b/test/xsd/H005/ebics_signature_S002.xsd @@ -0,0 +1,177 @@ + + + + + + ebics_signature enthält Typdefinitionen für elektronische Unterschriften der Versionen A005, A006 und folgende. + ebics_EU contains type definitions for electronic signatures: versions A005, A006 and et sqq. + + + + + XML-Strukturen für bankfachliche Elektronische Unterschriften (EUs). + contains the digital signatures. + + + + + enthält die EUs der Teilnehmer. + contains the digital signatures. + + + + + Datentyp für Signaturdaten des Teilnehmers beim EU-Transfer. + Data type for digital signature data transferred using EBICS. + + + + + bankfachliche Elektronische Unterschrift oder Transportunterschrift (strukturiertes Format). + Digital signature (either autorising an order or applied for transportation), structured format. + + + + + + + + Datentyp für kryptographische Unterschriften. + + + + + + bankfachliche Elektronische Unterschrift oder Transportunterschrift (strukturiertes Format). + Digital signature (either autorising an order or applied for transportation), structured format. + + + + + Datentyp für bankfachliche Elektronische Unterschrift oder Transportunterschrift (strukturiertes Format). + Data type according for a digital signature (either autorising an order or applied for transportation), structured format. + + + + + Version des Signaturverfahrens. + Version of the algorithm used for signature creation. + + + + + Digitale Signatur. + Digital signature. + + + + + Kunden-ID des Unterzeichners. + Customer ID of the signer. + + + + + Teilnehmer-ID. + User ID. + + + + + Parameter zur X.509-Funktionalität + Parameter for X509Data + + + + + + + Datentyp für eine Kunden-ID. + + + + + + + + Datentyp für eine Teilnehmer-ID. + + + + + + + + Datentyp für Versionsnummern zur Elektronischen Unterschrift (EU). + + + + + + + + + + Element für Public Key Dateien unabhängig von der Auftragsart / Geschäftsvorfall. + + + + + Datentyp für Public Key Dateien unabhängig von der Auftragsart / Geschäftsvorfall. + + + + + öffentlicher Signaturschlüssel. + + + + + Kunden-ID. + + + + + Teilnehmer-ID. + + + + + + + + öffentlicher Signaturschlüssel. + + + + + Datentyp für öffentliche bankfachliche Schlüssel. + + + + + + + Version des EU-Signaturverfahrens. + + + + + + + + + Datentyp für die Darstellung eines öffentlichen RSA-Schlüssels als Exponent-Modulus-Kombination oder als X509-Zertifikat. + + + + + + + + + Datentyp für Zeitstempel. + + + + diff --git a/test/xsd/H005/ebics_types_H005.xsd b/test/xsd/H005/ebics_types_H005.xsd new file mode 100644 index 0000000..ea13f06 --- /dev/null +++ b/test/xsd/H005/ebics_types_H005.xsd @@ -0,0 +1,1885 @@ + + + + + + + ebics_types_H005.xsd enthält einfache Typdefinitionen für EBICS. + + + + Datentyp für EBICS-Versionsnummern. + + + + + + + + + Datentyp für EBICS-Revisionsnummern. + + + + + + + + Datentyp für Versionsnummern zur Verschlüsselung. + + + + + + + + Datentyp für Versionsnummern zur Elektronischen Unterschrift (EU). + + + + + + + + + Datentyp für Versionsnummern zur Authentifikation. + + + + + + + + + Datentyp für Versionsnummern zur Verschlüsselung, Signatur und Authentifkation. + + + + + + Datentyp für Währungen (Grundtyp). + + + + + + + + + dreistelliger Währungscode gemäß ISO 4217. + + + + + + Afghanistan: Afghani + + + + + Albanien: Lek + + + + + Armenien: Dram + + + + + Niederländische Antillen: Gulden + + + + + Angola: Kwanza + + + + + Argentinien: Peso + + + + + Australien: Dollar + + + + + Aruba: Florin + + + + + Aserbaidschan: Manat + + + + + Bosnien und Herzegowina: Konvertible Mark + + + + + Barbados: Dollar + + + + + Bangladesch: Taka + + + + + Bulgarien: Lew + + + + + Bahrain: Dinar + + + + + Bermuda: Dollar + + + + + Brunei: Dollar + + + + + Bolivien: Boliviano + + + + + Brasilien: Real + + + + + Bahamas: Dollar + + + + + Bhutan: Ngultrum + + + + + Botswana: Pula + + + + + Weißrussland (Belarus): Rubel + + + + + Belize: Dollar + + + + + Kanada: Dollar + + + + + Demokratische Republik Kongo: Franc + + + + + Schweiz: Franken + + + + + Chile: Peso + + + + + China (Volksrepublik): Renminbi Yuan + + + + + Kolumbien: Peso + + + + + Costa Rica: Colón + + + + + Serbien: Dinar + + + + + Kuba: Peso + + + + + Kap Verde: Escudo + + + + + Zypern (griechischer Teil): Pfund + + + + + Tschechien: Krone + + + + + Dschibuti: Franc + + + + + Dänemark: Krone + + + + + Dominikanische Republik: Peso + + + + + Algerien: Dinar + + + + + Ecuador (bis 2000): Sucre + + + + + Estland: Krone + + + + + Ägypten: Pfund + + + + + Äthiopien: Birr + + + + + Europäische Währungsunion: Euro + + + + + Fidschi: Dollar + + + + + Falklandinseln: Pfund + + + + + Vereinigtes Königreich: Pfund + + + + + Georgien: Lari + + + + + Ghana: Cedi + + + + + Gibraltar: Pfund + + + + + Gambia: Dalasi + + + + + Guinea: Franc + + + + + Guatemala: Quetzal + + + + + Guyana: Dollar + + + + + Hongkong: Dollar + + + + + Honduras: Lempira + + + + + Kroatien: Kuna + + + + + Haiti: Gourde + + + + + Ungarn: Forint + + + + + Indonesien: Rupiah + + + + + Israel: Schekel + + + + + Indien: Rupie + + + + + Irak: Dinar + + + + + Iran: Rial + + + + + Island: Krone + + + + + Jamaika: Dollar + + + + + Jordanien: Dinar + + + + + Japan: Yen + + + + + Kenia: Schilling + + + + + Kirgisistan: Som + + + + + Kambodscha: Riel + + + + + Komoren: Franc + + + + + Nordkorea: Won + + + + + Südkorea: Won + + + + + Kuwait: Dinar + + + + + Kaimaninseln: Dollar + + + + + Kasachstan: Tenge + + + + + Laos: Kip + + + + + Libanon: Pfund + + + + + Sri Lanka: Rupie + + + + + Liberia: Dollar + + + + + Lesotho: Loti + + + + + Litauen: Litas + + + + + Lettland: Lats + + + + + Libyen: Dinar + + + + + Marokko: Dirham + + + + + Moldawien: Leu + + + + + Madagaskar: Franc + + + + + Mazedonien: Denar + + + + + Myanmar: Kyat + + + + + Mongolei: Tugrik + + + + + Macau: Pataca + + + + + Mauretanien: Ouguiya + + + + + Malta: Lira + + + + + Mauritius: Rupie + + + + + Malediven: Rufiyaa + + + + + Malawi: Kwacha + + + + + Mexiko: Peso + + + + + Malaysia: Ringgit + + + + + Mosambik: Metical + + + + + Namibia: Dollar + + + + + Nigeria: Naira + + + + + Nicaragua: Cordoba Oro + + + + + Norwegen: Krone + + + + + Nepal: Rupie + + + + + Neuseeland: Dollar + + + + + Oman: Rial + + + + + Panama: Balboa + + + + + Peru: Nuevo Sol + + + + + Papua-Neuguinea: Kina + + + + + Philippinen: Peso + + + + + Pakistan: Rupie + + + + + Polen: Zloty + + + + + Paraguay: Guaraní + + + + + Katar: Riyal + + + + + Rumänien: Leu + + + + + Russland: Rubel + + + + + Ruanda: Franc + + + + + Saudi-Arabien: Riyal + + + + + Salomonen: Dollar + + + + + Seychellen: Rupie + + + + + Sudan: Dinar + + + + + Schweden: Krone + + + + + Singapur: Dollar + + + + + St. Helena: Pfund + + + + + Slowenien: Tolar + + + + + Slowakei: Krone + + + + + Sierra Leone: Leone + + + + + Somalia: Schilling + + + + + Suriname: Dollar + + + + + São Tomé und Príncipe: Dobra + + + + + El Salvador: Colón + + + + + Syrien: Pfund + + + + + Swasiland: Lilangeni + + + + + Thailand: Baht + + + + + Tadschikistan: Somoni + + + + + Turkmenistan: Manat + + + + + Tunesien: Dinar + + + + + Tonga: Pa'anga + + + + + Türkei: Lira + + + + + Türkei: Neue Lira (ab 2005) + + + + + Trinidad und Tobago: Dollar + + + + + Taiwan: Dollar + + + + + Tansania: Schilling + + + + + Ukraine: Hrywnja + + + + + Uganda: Shilling + + + + + USA: Dollar + + + + + Uruguay: Peso + + + + + Usbekistan: Sum + + + + + Venezuela: Bolivar + + + + + Vietnam: Dong + + + + + Vanuatu: Vatu + + + + + Samoa: Tala + + + + + Zentralafrikanische Wirtschafts- und Währungsunion: CFA-Franc + + + + + Ostkaribische Währungsunion: Dollar + + + + + Westafrikanische Wirtschafts- und Währungsunion: CFA-Franc + + + + + Neukaledonien: CFP-Franc + + + + + Spezialcode für Testzwecke; keine existierende Währung + + + + + keine Währung + + + + + Jemen: Rial + + + + + Südafrika: Rand + + + + + Sambia: Kwacha + + + + + Simbabwe: Dollar + + + + + + + Datentyp für einen Betragswert (ohne Währung). + + + + + + + + + Datentyp für einen Betrag inkl. Währungscode-Attribut (Default = "EUR"). + + + + + + Währungscode, Default="EUR". + Currency code, default setting is "EUR". + + + + + + + + Datentyp für die Transaktions-ID. + + + + + + + + Datentyp für Nonces. + + + + + + + + Datentyp für die Instituts-ID. + + + + + + + + Datentyp für die Host-ID. + + + + + + + + Datentyp für die Kundenprodukt-ID. + + + + + + + + Datentyp für das Sprachkennzeichen des Kundenprodukts. + + + + + + + + Datentyp für allgemeine Auftragsarten (Grundtyp). + + + + + + + + + Datentyp für eine Auftragsnummer lt. DFÜ-Abkommen. + + + + + + + + + Datentyp für das Sicherheitsmedium. + + + + + + + + + Datentyp für die Segmentnummer. + + + + + + + + Datentyp für die Gesamtsegmentanzahl. + + + + + + + + Datentyp für die Gesamtanzahl der Einzelauftraginfos. + + + + + + + + Datentyp für die Transaktionsphase. + + + + + Transaktionsinitialisierung + + + + + Auftragsdatentransfer + + + + + Quittungstransfer + + + + + + + Datentyp für Zeitstempel. + + + + + + Datentyp für Datumswerte. + + + + + + Datentyp für eine Teilnehmer-ID. + + + + + + + + + Datentyp für eine Kunden-ID. + + + + + + + + + Datentyp für eine Konten-ID. + + + + + + + + Datentyp für eine Kontonummer (national/international). + + + + + + + + + Datentyp für eine Bankleitzahl (national/international). + + + + + + + + + Datentyp für ein nationales BLZ-Präfix. + + + + + + + + Datentyp für eine Kontonummer (freies Format). + + + + + + + + Datentyp für eine Bankleitzahl (freies Format). + + + + + + + + Datentyp für den Namen des Kontoinhabers. + + + + + + Datentyp für die Kontobeschreibung. + + + + + + Datentyp für Kontoinformationen. + + + + + + Kontonummer (deutsches Format und/oder international als IBAN). + Account number (German format and/or international=IBAN). + + + + + + + Ist die Kontonummer im deutschen Format (international=false) oder im internationalen Format (international=true, IBAN) angegeben? + Is the account number specified using the national=German or the international=IBAN format? + + + + + + + + + Kontonummer im freien Format. + Account in free format. + + + + + + + Formatkennung. + Format identification. + + + + + + + + + + + Bankleitzahl (deutsches Format und/oder international als SWIFT-BIC). + Bank code (German and/or international=SWIFT-BIC). + + + + + + + Ist die Bankleitzahl im deutschen Format (international=false, BLZ) oder im internationalen Format (international=true, SWIFT-BIC) angegeben? + Is the bank code specified using the national=German or the international SWIFT-BIC format? + + + + + nationales Präfix für Bankleitzahlen. + National=German prefix for bank codes. + + + + + + + + + Bankleitzahl im freien Format. + Bank code in free format. + + + + + + + Formatkennung. + Format identification. + + + + + + + + + + Name des Kontoinhabers. + Name of the account holder. + + + + + + Währungscode für dieses Konto, Default=EUR. + Currency code for this account, Default=EUR. + + + + + Kontobeschreibung. + Description of this account. + + + + + + Datentyp für die Rolle eines Zahlungsverkehrskontos innerhalb einer Transaktion. + + + + + Auftraggeberkonto + + + + + Empfängerkonto + + + + + Gebührenkonto + + + + + andere Kontorolle + + + + + + + Datentyp für die Rolle eines Kreditinstituts innerhalb einer Transaktion (repräsentiert durch die Bankleitzahl). + + + + + Auftraggeberbank + + + + + Empfängerbank + + + + + Korrespondenzbank + + + + + andere Bankrolle + + + + + + + Datentyp für die Rolle eines Kontoinhabers innerhalb einer Transaktion. + + + + + Auftraggeber + + + + + Empfänger + + + + + Überbringer, Einreicher + + + + + andere Rolle + + + + + + + Datentyp für Kontoinformationen inkl. der Eigenschaftszuordnung innerhalb einer Zahlungstransaktion. + + + + + + Kontonummer (deutsches Format oder international als IBAN). + Kontonummer (Account number (German format and/or international = IBAN). + + + + + + + Rolle des Kontos innerhalb der Zahlungstransaktion. + Role of the account during the transaction. + + + + + Textuelle Beschreibung der Funktion, falls role=Other ausgewählt wird. + Textual description of the role the account place during the transaction; use only if the corresponding 'role' field is set to 'other'. + + + + + Ist die Kontonummer im deutschen Format (international=false) oder im internationalen Format (international=true, IBAN) angegeben? + Is the account number specified using the national=German or the international=IBAN format? + + + + + + + + + Kontonummer im freien Format. + Account in free format. + + + + + + + Rolle des Kontos innerhalb der Zahlungstransaktion. + Role of the account during the transaction. + + + + + Textuelle Beschreibung der Funktion, falls role=Other ausgewählt wird. + Textual description of the role the account place during the transaction; use only if the corresponding 'role' field is set to 'other'. + + + + + Formatkennung. + Format identification. + + + + + + + + + + + Bankleitzahl (deutsches Format oder international als SWIFT-BIC). + Bank code (German and/or international=SWIFT-BIC). + + + + + + + Rolle des kontoführenden Instituts innerhalb der Zahlungstransaktion. + Role of the bank during the transaction. + + + + + Textuelle Beschreibung der Funktion, falls role=Other ausgewählt wird. + Textual description of the role the account place during the transaction; use only if the corresponding 'role' field is set to 'other'. + + + + + Ist die Bankleitzahl im deutschen Format (international=false, BLZ) oder im internationalen Format (international=true, SWIFT-BIC) angegeben? + Is the bank code specified using the national=German or the international=SWIFT-BIC format? + + + + + nationales Präfix für Bankleitzahlen. + National=German prefix for bank codes. + + + + + + + + + Bankleitzahl im freien Format. + Bank code in free format. + + + + + + + Rolle des kontoführenden Instituts innerhalb der Zahlungstransaktion. + Role of the bank during the transaction. + + + + + Textuelle Beschreibung der Funktion, falls role=Other ausgewählt wird. + Textual description of the role the account place during the transaction; use only if the corresponding 'role' field is set to 'other'. + + + + + Formatkennung. + Format identification. + + + + + + + + + + Name des Kontoinhabers. + Name of the account holder. + + + + + + + Rolle des Kontoinhabers innerhalb der Zahlungstransaktion. + Role of the account holder during the transaction. + + + + + Textuelle Beschreibung der Rolle, falls role=Other ausgewählt wird. + Textual description of the role the account holder place during the transaction; use only if the corresponding 'role' field is set to 'other'. + + + + + + + + + + Währungscode für dieses Konto, Default=EUR. + Currency code for this account, Default=EUR. + + + + + Kontobeschreibung. + Description of this account. + + + + + + Datentyp für binäre Signaturdaten (komprimiert, verschlüsselt und kodiert). + + + + + + Datentyp für binäre Auftragsdaten (komprimiert, verschlüsselt und kodiert). + + + + + + Datentyp für Berechtigungsklassen zur Elektronischen Unterschrift. + + + + + + Einzelunterschrift + + + + + Erstunterschrift + + + + + Zweitunterschrift + + + + + Transportunterschrift + + + + + + + Listentyp für Berechtigungsklassen zur Elektronischen Unterschrift. + + + + + + Datentyp für Hashfunktionen. + + + + + + Datentyp für Hashwerte. + + + + + + + + + Version des Signaturverfahrens. + Version of the algorithm used for signature creation. + + + + + + + + Datentyp für kryptographische Unterschriften. + + + + + + Datentyp für symmetrische Schlüssel. + + + + + + Datentyp für Hashwerte und Attribute von öffentlichen Schlüsseln. + + + + + + Hashalgorithmus. + Name of the used hash algorithm. + + + + + + + + Datentyp für die Darstellung eines öffentlichen RSA-Schlüssels als Exponent-Modulus-Kombination oder als X509-Zertifikat. + + + + + + + + + Datentyp für öffentliche Verschlüsselungsschlüssel. + + + + + + + Version des Verschlüsselungsverfahrens. + + + + + + + + + Datentyp für öffentlichen Authentfikationsschlüssel. + + + + + + + Version des Authentifikationsverfahrens. + + + + + + + + + Datentyp für öffentliche bankfachliche Schlüssel. + Data type for public authorisation (ES) key. + + + + + + + Version des EU-Signaturverfahrens. + ES-Version. + + + + + + + + + Datentyp für öffentlichen Schlüssel zur Authentisierung. + Data type for public for identification and authentication. + + + + + + + Version des Authentifikationsverfahrens. + Authentication version. + + + + + + + + + Datentyp für öffentlichen Verschlüsselungsschlüssel. + Data type for encryption key. + + + + + + + Version des Verschlüsselungsverfahrens. + Encryption Version. + + + + + + + + + Datentyp für die Zertifikate hinsichtlich der "bank-technical signature for authorisation" (ES). + Data Type for Certificates for the bank-technical signature for authorisation (ES) + + + + + + + + + Datentyp für Antwortcodes. + + + + + + + + + Datentyp für den Erklärungstext zum Antwortcode. + + + + + + + + Datentyp für Quittierungscodes. + + + + + + + + + Datentyp für Kunden-, Teilnehmer-, Straßen- oder Ortsnamen. + + + + + + Datentyp für die Beschreibung von Auftragsarten. + + + + + + + + Datentyp für den Teilnehmerstatus. + + + + + + + + generic parameter + Generic key value parameters. + + + + + + name of parameter + Name of the parameter (= key). + + + + + value of parameter + Value of the parameter. + + + + + + + XML-Typ des Parameterwerts (Vorschlag für default ist string). + XML type of the parameter value (Proposal for default is string). + + + + + + + + + + + + Datentyp für die Darstellung von Information zur Verschlüsselung der Auftragsdaten. + Data type for the modelling of information regarding the encryption of signature and order data. + + + + + Hashwert des öffentlichen Verschlüsselungsschlüssels des Empfängers der verschlüsselten Auftragsdaten. + Hash value of the public encryption key owned by the receipient of the encrypted order data. + + + + + + + Version des Verschlüsselungsverfahrens. + Version of the encryption method. + + + + + + + + + Asymmetrisch verschlüsselter symmetrischer Transaktionsschlüssel. + The asymmetrically encrypted symmetric transaction key. + + + + + + + + Authentifikationssignatur. + Authentication signature. + + + + + String up to 255 characters. + + + + + + + + + + + + + + + + Type is used for ISO variant and version + + + + + + + + + + Type ist used for original file name + + + + + + + + + Type ist used for name or rather kind of Message + + + + + + + + + + Service Code name: External list specified and maintained by EBICS. Basis is the "SWIFT-list" for the field "description" (SCT, DCT, XCT, SDD, DDD, STM, REP...) plus additional codes needed for further services + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/test/xsd/H005/xmldsig-core-schema.xsd b/test/xsd/H005/xmldsig-core-schema.xsd new file mode 100644 index 0000000..1698c2f --- /dev/null +++ b/test/xsd/H005/xmldsig-core-schema.xsd @@ -0,0 +1,318 @@ + + + + + + ]> + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/types/bankLetter.d.ts b/types/bankLetter.d.ts new file mode 100644 index 0000000..54d347f --- /dev/null +++ b/types/bankLetter.d.ts @@ -0,0 +1,13 @@ +import { Client } from "./client"; + +export interface BankLetterOptions { + client: Client; + bankName: string; + template: string; +} + +export class BankLetter { + constructor(options: BankLetterOptions); + generate(): Promise; + serialize(path: string): Promise; +} diff --git a/types/client.d.ts b/types/client.d.ts new file mode 100644 index 0000000..014035a --- /dev/null +++ b/types/client.d.ts @@ -0,0 +1,56 @@ +import { BankKeys } from "./keys"; +import { + DownloadOrder, + KeyManagementOrder, + Order, + UploadOrder, +} from "./orders"; +import { FsKeysStorage, TracesStorage } from "./storages"; + +export interface ClientOptions { + url: string; + partnerId: string; + userId: string; + hostId: string; + passphrase: string | Buffer; + iv: string | Buffer; + keyStorage: FsKeysStorage; + tracesStorage?: TracesStorage; + bankName?: string; + bankShortName?: string; + languageCode?: string; + storageLocation?: string; +} + +export class Client { + constructor(options: ClientOptions); + send(order: KeyManagementOrder): Promise; + send(order: UploadOrder): Promise; + send(order: DownloadOrder): Promise; + send(order: Order): Promise; + setBankKeys(bankKeys: BankKeys): Promise; +} + +export interface EbicsBaseResponse { + transactionId?: string; + orderId: string; + technicalCode: string; + technicalCodeSymbol: string; + technicalCodeShortText: string; + technicalCodeMeaning: string; + businessCode: string; + businessCodeSymbol: string; + businessCodeShortText: string; + businessCodeMeaning: string; +} + +export interface EbicsUploadResponse extends EbicsBaseResponse {} + +export interface EbicsKeyManagementResponse extends EbicsBaseResponse { + orderData: string; + bankKeys: BankKeys; +} + +export interface EbicsDownloadResponse extends EbicsBaseResponse { + orderData: Buffer; +} diff --git a/types/index.d.ts b/types/index.d.ts new file mode 100644 index 0000000..51a9770 --- /dev/null +++ b/types/index.d.ts @@ -0,0 +1,6 @@ +export * from "./bankLetter"; +export * from "./client"; +export * from "./orders"; +export * from "./ordersH004"; +export * from "./ordersH005"; +export * from "./storages"; diff --git a/types/keys.d.ts b/types/keys.d.ts new file mode 100644 index 0000000..0f39c7b --- /dev/null +++ b/types/keys.d.ts @@ -0,0 +1,4 @@ +export interface BankKeys { + bankX002: string; + bankE002: string; +} diff --git a/types/orders.d.ts b/types/orders.d.ts new file mode 100644 index 0000000..1a8d331 --- /dev/null +++ b/types/orders.d.ts @@ -0,0 +1,19 @@ +import { + DownloadOrderH004, + KeyManagementOrderH004, + OrderH004, + UploadOrderH004, +} from "./ordersH004"; +import { + DownloadOrderH005, + KeyManagementOrderH005, + OrderH005, + UploadOrderH005, +} from "./ordersH005"; + +export type Order = OrderH004 | OrderH005; +export type KeyManagementOrder = + | KeyManagementOrderH004 + | KeyManagementOrderH005; +export type DownloadOrder = DownloadOrderH004 | DownloadOrderH005; +export type UploadOrder = UploadOrderH004 | UploadOrderH005; diff --git a/types/ordersH004.d.ts b/types/ordersH004.d.ts new file mode 100644 index 0000000..26c4a3c --- /dev/null +++ b/types/ordersH004.d.ts @@ -0,0 +1,78 @@ +export interface KeyManagementOrderH004 { + version: "h004"; + orderDetails: { + OrderType: string; + OrderAttribute: "DZNNN" | "DZHNN" | "OZHNN"; + }; + operation: "ini" | "upload" | "download"; +} + +export interface UploadOrderH004 { + version: "h004"; + orderDetails: { + OrderType: string; + OrderAttribute: "OZHNN"; + }; + document: string | Buffer; + operation: "upload"; +} + +export interface DownloadOrderH004 { + orderDetails: { + OrderType: string; + OrderAttribute: "DZHNN"; + StandardOrderParams: { + Start: string; + End: string; + }; + }; + operation: "download"; +} + +export type OrderH004 = + | KeyManagementOrderH004 + | UploadOrderH004 + | DownloadOrderH004; + +export interface PredefinedUploadFunctionH004 { + (document: string | Buffer): UploadOrderH004; +} + +export interface PredefinedDownloadFunctionH004 { + (start: string | Date, end: string | Date): DownloadOrderH004; +} + +export namespace OrdersH004 { + export const INI: KeyManagementOrderH004; + export const HIA: KeyManagementOrderH004; + export const HPB: KeyManagementOrderH004; + export const Z53: PredefinedDownloadFunctionH004; + + export const AZV: PredefinedUploadFunctionH004; + export const CD1: PredefinedUploadFunctionH004; + export const CDB: PredefinedUploadFunctionH004; + export const CDD: PredefinedUploadFunctionH004; + export const CDS: PredefinedUploadFunctionH004; + export const CCT: PredefinedUploadFunctionH004; + export const CCS: PredefinedUploadFunctionH004; + export const XE3: PredefinedUploadFunctionH004; + export const XCT: PredefinedUploadFunctionH004; + export const XG1: PredefinedUploadFunctionH004; + export const G1V: PredefinedUploadFunctionH004; + export const G1R: PredefinedUploadFunctionH004; + + export const STA: PredefinedDownloadFunctionH004; + export const VMK: PredefinedDownloadFunctionH004; + export const HAA: DownloadOrderH004; + export const HTD: DownloadOrderH004; + export const HPD: DownloadOrderH004; + export const HKD: DownloadOrderH004; + export const PTK: PredefinedDownloadFunctionH004; + export const HAC: PredefinedDownloadFunctionH004; + export const DKI: PredefinedDownloadFunctionH004; + export const C52: PredefinedDownloadFunctionH004; + export const C53: PredefinedDownloadFunctionH004; + export const G52: PredefinedDownloadFunctionH004; + export const G53: PredefinedDownloadFunctionH004; + export const G02: PredefinedDownloadFunctionH004; +} diff --git a/types/ordersH005.d.ts b/types/ordersH005.d.ts new file mode 100644 index 0000000..e19a807 --- /dev/null +++ b/types/ordersH005.d.ts @@ -0,0 +1,125 @@ +// Key management orders +export interface KeyManagementOrderH005 { + version: "h005"; + orderDetails: { + AdminOrderType: "INI" | "HIA" | "HPB"; + }; + operation: "ini"; +} + +// Upload and download orders +interface UploadOrderParamsH005 { + Service: { + ServiceName: string; + Scope?: string; + ServiceOption?: string; + }; + Container?: { + "@": { + containerType: string; + }; + }; + MsgName: { + "#": string; + "@": { + version?: string; + variant?: string; + format?: string; + }; + }; +} + +interface DownloadOrderParamsH005 extends UploadOrderParamsH005 { + DateRange?: { + Start?: string; + End?: string; + }; +} + +export interface UploadOrderH005 { + version: "h005"; + orderDetails: { + AdminOrderType: "BTU"; + BTUOrderParams: UploadOrderParamsH005; + }; + operation: "upload"; +} + +export interface DownloadOrderH005 { + version: "h005"; + orderDetails: { + AdminOrderType: "BTD"; + BTDOrderParams: DownloadOrderParamsH005; + }; + operation: "download"; +} + +// All orders +export type OrderH005 = + | KeyManagementOrderH005 + | UploadOrderH005 + | DownloadOrderH005; + +// Order factory options & predefined orders +export interface GenericUploadOrderOptionsH005 { + serviceName: string; + msgName: string; + msgVersion?: string; + msgVariant?: string; + msgFormat?: string; + scope?: string; + serviceOption?: string; + containerType?: string; +} + +export interface GenericDownloadOrderOptionsH005 + extends GenericUploadOrderOptionsH005 { + start?: string | Date; + end?: string | Date; +} + +export type PredefinedUploadOrderOptionsH005 = Omit< + GenericUploadOrderOptionsH005, + "serviceName" | "msgName" +>; +export type PredefinedDownloadOrderOptionsH005 = Omit< + GenericDownloadOrderOptionsH005, + "serviceName" | "msgName" +>; + +export interface PredefinedUploadFunctionH005 { + ( + document: string | Buffer, + options?: PredefinedUploadOrderOptionsH005 + ): UploadOrderH005; +} + +export interface PredefinedDownloadFunctionH005 { + (options?: PredefinedDownloadOrderOptionsH005): DownloadOrderH005; +} + +export namespace OrdersH005 { + export const INI: KeyManagementOrderH005; + export const HIA: KeyManagementOrderH005; + export const HPB: KeyManagementOrderH005; + + export const DCT: PredefinedUploadFunctionH005; + export const DDD: PredefinedUploadFunctionH005; + export const MCT: PredefinedUploadFunctionH005; + export const SCT: PredefinedUploadFunctionH005; + export const SDD: PredefinedUploadFunctionH005; + export const XCT: PredefinedUploadFunctionH005; + + export const EOP: PredefinedDownloadFunctionH005; + export const PSR: PredefinedDownloadFunctionH005; + export const REP: PredefinedDownloadFunctionH005; + export const STM: PredefinedDownloadFunctionH005; + + export function genericUpload( + document: string | Buffer, + options: GenericUploadOrderOptionsH005 + ): UploadOrderH005; + export function genericDownload( + options: GenericDownloadOrderOptionsH005 + ): DownloadOrderH005; +} diff --git a/types/storages.d.ts b/types/storages.d.ts new file mode 100644 index 0000000..02b1f1a --- /dev/null +++ b/types/storages.d.ts @@ -0,0 +1,24 @@ +export function fsKeysStorage(pathToFile: string): FsKeysStorage; +export function tracesStorage(pathToFile: string): TracesStorage; + +export interface FsKeysStorage { + read(): Promise; + write(data: string): Promise; +} + +export interface TracesStorage { + traceData: string; + traceLabel: string; + lastTraceID: string | null; + connectToLastTrace: boolean; + label(str: string): TracesStorage; + data(data: string): TracesStorage; + ofType(type: string): TracesStorage; + new (): TracesStorage; + connect(): TracesStorage; + persist(): TracesStorage; + reset(): TracesStorage; + getTraceName(label: string, type: string, ext: string): string; + getTracePath(label: string, type: string, ext: string): string; + getTracePath(label: string, type: string, ext: string): string; +}