czech-data-box 0.1.0

package/src/lib/ISDSSoapClient.js

@@ -0,0 +1,201 @@
+import { constants } from 'crypto'; // Use the crypto module for constants
+import fs from 'fs';
+import soap from 'soap';
+import http from 'http';
+import https from 'https';
+import os from 'os';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+import { DEBUG } from './config.js';
+
+// Ensure Buffer is available globally (mostly needed in non-Node.js environments)
+if (typeof Buffer === 'undefined') {
+  global.Buffer = require('buffer').Buffer;
+}
+
+// Define the dirname constant
+const __filename = fileURLToPath(import.meta.url);
+const dirname = path.dirname(__filename);
+
+class ISDSSoapClient {
+  constructor(wsdl, options, debug = DEBUG) {
+    this.client = null;
+    this.wsdl = wsdl;
+    this.options = options;
+    this.debug = debug;
+  }
+
+  async init() {
+    try {
+      // Default wsdl_options
+      let wsdl_options = {
+        rejectUnauthorized: false,
+        secureOptions:
+          constants.SSL_OP_NO_SSLv3 |
+          constants.SSL_OP_NO_TLSv1 |
+          constants.SSL_OP_NO_TLSv1_1 |
+          constants.SSL_OP_NO_COMPRESSION,
+        ciphers: 'HIGH:!aNULL:!MD5:!3DES', // Only use strong ciphers
+      };
+
+      // Conditionally set SSL version for non-Windows systems
+      if (os.platform() !== 'win32') {
+        wsdl_options.secureProtocol = 'TLSv1_3_method'; // Example: force TLSv1.2
+      }
+
+      // Conditionally add client certificate, private key, and CA if loginType is 1
+      if (this.options.loginType === 1) {
+        (wsdl_options.cert = this.options.publicKey),
+          (wsdl_options.key = this.options.privateKey),
+          (wsdl_options.ca = fs.readFileSync(
+            path.join(
+              dirname,
+              '..',
+              '..',
+              'resources',
+              'certs',
+              'cacert_postsignum_vca4.pem',
+            ),
+          ));
+      }
+
+      const clientOptions = {
+        ...this.options,
+        wsdl_options,
+        httpClient: {
+          request: (rurl, data, callback, exheaders) => {
+            const headers = exheaders || {};
+            headers['Content-Length'] = Buffer.byteLength(data, 'utf8');
+
+            const options = {
+              method: 'POST',
+              headers: headers,
+              rejectUnauthorized: wsdl_options.rejectUnauthorized,
+              followAllRedirects: true, // Equivalent to CURLOPT_FOLLOWLOCATION
+              timeout: 30000, // Set a timeout as needed
+              agentOptions: {
+                secureOptions: wsdl_options.secureOptions,
+                secureProtocol: wsdl_options.secureProtocol,
+                ciphers: wsdl_options.ciphers,
+              },
+            };
+
+            // Conditionally add client certificate, private key, and CA if loginType is 1
+            if (this.options.loginType === 1) {
+              options.cert = wsdl_options.cert;
+              options.key = wsdl_options.key;
+              options.ca = wsdl_options.ca;
+            }
+
+            const protocol = /^https/.test(rurl) ? https : http;
+
+            const req = protocol.request(rurl, options, (res) => {
+              let body = '';
+              res.setEncoding('utf8');
+              res.on('data', (chunk) => {
+                body += chunk;
+              });
+              res.on('end', () => {
+                callback(null, res, body);
+              });
+            });
+
+            req.on('error', (err) => {
+              console.error('Request error:', err); // Improved logging
+              callback(err);
+            });
+
+            req.write(data);
+            req.end();
+          },
+        },
+      };
+
+      if (this.debug) {
+        console.log(`Initializing SOAP client with WSDL: ${this.wsdl}`);
+      }
+
+      this.client = await soap.createClientAsync(this.wsdl, clientOptions);
+
+      // Override the endpoint URL with the one specified in the options
+      this.client.setEndpoint(this.options.location);
+
+      // Add common HTTP headers to each request
+      this.client.addHttpHeader('Method', 'POST');
+      this.client.addHttpHeader('Connection', 'Keep-Alive');
+      this.client.addHttpHeader('User-Agent', 'Node-SOAP-Client');
+      this.client.addHttpHeader('Content-Type', 'text/xml; charset=utf-8');
+
+      // Add Authorization header to each request
+      if (this.options.loginType === 0) {
+        this.client.setSecurity(
+          new soap.BasicAuthSecurity(this.options.login, this.options.password),
+        );
+      } else if (this.options.loginType === 1) {
+        const wsSecurity = new soap.WSSecurityCert(
+          this.options.privateKey,
+          this.options.publicKey,
+          this.options.passPhrase,
+        );
+        this.client.setSecurity(wsSecurity);
+      } else {
+        this.client.addHttpHeader(
+          'Authorization',
+          `Basic ${Buffer.from(`${this.options.login}:${this.options.password}`).toString('base64')}`,
+        );
+      }
+
+      // Enable debug logging if necessary
+      if (this.debug === true) {
+        this.client.on('request', (xml) => {
+          console.log('Request:', xml);
+          fs.writeFile('soap-request-debug.xml', xml, (err) => {
+            if (err) {
+              console.error('Error writing XML to file:', err);
+            } else {
+              console.log(
+                'XML request successfully written to file request.xml',
+              );
+            }
+          });
+        });
+        this.client.on('response', (xml, response) => {
+          console.log('Response:', response);
+        });
+      }
+    } catch (error) {
+      console.error('Error initializing SOAP client:', error);
+      throw error;
+    }
+  }
+
+  async request(method, args) {
+    if (!this.client) {
+      await this.init();
+    }
+
+    if (this.debug) {
+      console.log(
+        `Making SOAP request to method: ${method} with args: ${JSON.stringify(args)}`,
+      );
+    }
+    try {
+      const result = await this.client[`${method}Async`](args);
+      if (this.debug === true) {
+        console.log(`SOAP Response for method ${method}:`, result);
+      }
+      return result;
+    } catch (error) {
+      console.error(`Error in SOAP request for method ${method}:`, error);
+      if (error.response) {
+        console.error('Error Response Data:', error.response.data);
+        console.error('Error Response Status:', error.response.status);
+        console.error('Error Response Headers:', error.response.headers);
+      }
+      throw error;
+    }
+  }
+}
+
+export default ISDSSoapClient;

package/src/lib/config.js

@@ -0,0 +1,64 @@
+// config.js
+import path from 'path';
+
+export const DEBUG = false; // Set to true to enable debug mode globally
+
+function getServiceURL(serviceType, loginType, productionMode) {
+  let baseURL = 'https://ws1';
+  if (loginType !== 0) {
+    baseURL += 'c';
+  }
+
+  if (productionMode === false) {
+    baseURL += '.czebox.cz/';
+  } else if (productionMode === true) {
+    baseURL += '.mojedatovaschranka.cz/';
+  }
+
+  if (loginType === 1) {
+    baseURL += 'cert/';
+  }
+
+  baseURL += 'DS/';
+
+  switch (serviceType) {
+    case 0:
+      return `${baseURL}dz`;
+    case 1:
+      return `${baseURL}dx`;
+    case 2:
+      return `${baseURL}DsManage`;
+    case 3:
+      return `${baseURL}DsManage`;
+    case 4:
+      return `${baseURL}df`;
+    default:
+      throw new Error('Invalid service type');
+  }
+}
+
+function getServiceWSDL(serviceType) {
+  const directory = path.join(
+    path.dirname(new URL(import.meta.url).pathname),
+    '..',
+    '..',
+    'resources',
+    'wsdl',
+  );
+  switch (serviceType) {
+    case 0:
+      return path.join(directory, 'dm_operations.wsdl');
+    case 1:
+      return path.join(directory, 'dm_info.wsdl');
+    case 2:
+      return path.join(directory, 'db_manipulations.wsdl');
+    case 3:
+      return path.join(directory, 'db_access.wsdl');
+    case 4:
+      return path.join(directory, 'db_search.wsdl');
+    default:
+      throw new Error('Invalid service type');
+  }
+}
+
+export { getServiceURL, getServiceWSDL };

package/src/models/DataBox.js

@@ -0,0 +1,142 @@
+// src/models/DataBox.js
+class DataBox {
+  constructor() {
+    this.dbOwnerInfo = {};
+  }
+
+  setDbId(value) {
+    this.dbOwnerInfo.dbID = value;
+    return this;
+  }
+
+  setDbType(value) {
+    this.dbOwnerInfo.dbType = value;
+    return this;
+  }
+
+  setIc(value) {
+    this.dbOwnerInfo.ic = value;
+    return this;
+  }
+
+  setPnFirstName(value) {
+    this.dbOwnerInfo.pnFirstName = value;
+    return this;
+  }
+
+  setPnMiddleName(value) {
+    this.dbOwnerInfo.pnMiddleName = value;
+    return this;
+  }
+
+  setPnLastName(value) {
+    this.dbOwnerInfo.pnLastName = value;
+    return this;
+  }
+
+  setPnLastNameAtBirth(value) {
+    this.dbOwnerInfo.pnLastNameAtBirth = value;
+    return this;
+  }
+
+  setFirmName(value) {
+    this.dbOwnerInfo.firmName = value;
+    return this;
+  }
+
+  setBiDate(value) {
+    this.dbOwnerInfo.biDate = value;
+    return this;
+  }
+
+  setBiCity(value) {
+    this.dbOwnerInfo.biCity = value;
+    return this;
+  }
+
+  setBiCounty(value) {
+    this.dbOwnerInfo.biCounty = value;
+    return this;
+  }
+
+  setBiState(value) {
+    this.dbOwnerInfo.biState = value;
+    return this;
+  }
+
+  setAdCity(value) {
+    this.dbOwnerInfo.adCity = value;
+    return this;
+  }
+
+  setAdStreet(value) {
+    this.dbOwnerInfo.adStreet = value;
+    return this;
+  }
+
+  setAdNumberInStreet(value) {
+    this.dbOwnerInfo.adNumberInStreet = value;
+    return this;
+  }
+
+  setAdNumberInMunicipality(value) {
+    this.dbOwnerInfo.adNumberInMunicipality = value;
+    return this;
+  }
+
+  setAdZipCode(value) {
+    this.dbOwnerInfo.adZipCode = value;
+    return this;
+  }
+
+  setAdState(value) {
+    this.dbOwnerInfo.adState = value;
+    return this;
+  }
+
+  setNationality(value) {
+    this.dbOwnerInfo.nationality = value;
+    return this;
+  }
+
+  setEmail(value) {
+    this.dbOwnerInfo.email = value;
+    return this;
+  }
+
+  setTelNumber(value) {
+    this.dbOwnerInfo.telNumber = value;
+    return this;
+  }
+
+  setIdentifier(value) {
+    this.dbOwnerInfo.identifier = value;
+    return this;
+  }
+
+  setRegistryCode(value) {
+    this.dbOwnerInfo.registryCode = value;
+    return this;
+  }
+
+  setDbState(value) {
+    this.dbOwnerInfo.dbState = value;
+    return this;
+  }
+
+  setDbEffectiveOVM(value) {
+    this.dbOwnerInfo.dbEffectiveOVM = value;
+    return this;
+  }
+
+  setDbOpenAddressing(value) {
+    this.dbOwnerInfo.dbOpenAddressing = value;
+    return this;
+  }
+
+  build() {
+    return { dbOwnerInfo: this.dbOwnerInfo };
+  }
+}
+
+export default DataBox;

package/src/models/DataMessage.js

@@ -0,0 +1,153 @@
+// models/DataMessage.js
+class DataMessage {
+  constructor({
+    dmSenderOrgUnit = null,
+    dmSenderOrgUnitNum = null,
+    dbIDRecipient = null,
+    dmRecipientOrgUnit = null,
+    dmRecipientOrgUnitNum = null,
+    dmToHands = null,
+    dmAnnotation = null,
+    dmRecipientRefNumber = null,
+    dmSenderRefNumber = null,
+    dmRecipientIdent = null,
+    dmSenderIdent = null,
+    dmLegalTitleLaw = null,
+    dmLegalTitleYear = null,
+    dmLegalTitleSect = null,
+    dmLegalTitlePar = null,
+    dmLegalTitlePoint = null,
+    dmPersonalDelivery = false,
+    dmAllowSubstDelivery = false,
+    dmOVM = false,
+    dmPublishOwnID = false,
+  } = {}) {
+    this.dmSenderOrgUnit = dmSenderOrgUnit;
+    this.dmSenderOrgUnitNum = dmSenderOrgUnitNum;
+    this.dbIDRecipient = dbIDRecipient;
+    this.dmRecipientOrgUnit = dmRecipientOrgUnit;
+    this.dmRecipientOrgUnitNum = dmRecipientOrgUnitNum;
+    this.dmToHands = dmToHands;
+    this.dmAnnotation = dmAnnotation;
+    this.dmRecipientRefNumber = dmRecipientRefNumber;
+    this.dmSenderRefNumber = dmSenderRefNumber;
+    this.dmRecipientIdent = dmRecipientIdent;
+    this.dmSenderIdent = dmSenderIdent;
+    this.dmLegalTitleLaw = dmLegalTitleLaw;
+    this.dmLegalTitleYear = dmLegalTitleYear;
+    this.dmLegalTitleSect = dmLegalTitleSect;
+    this.dmLegalTitlePar = dmLegalTitlePar;
+    this.dmLegalTitlePoint = dmLegalTitlePoint;
+    this.dmPersonalDelivery = dmPersonalDelivery;
+    this.dmAllowSubstDelivery = dmAllowSubstDelivery;
+    this.dmOVM = dmOVM;
+    this.dmPublishOwnID = dmPublishOwnID;
+  }
+
+  setDmSenderOrgUnit(value) {
+    this.dmSenderOrgUnit = value;
+  }
+
+  setDmSenderOrgUnitNum(value) {
+    this.dmSenderOrgUnitNum = value;
+  }
+
+  setDbIDRecipient(value) {
+    this.dbIDRecipient = value;
+  }
+
+  setDmRecipientOrgUnit(value) {
+    this.dmRecipientOrgUnit = value;
+  }
+
+  setDmRecipientOrgUnitNum(value) {
+    this.dmRecipientOrgUnitNum = value;
+  }
+
+  setDmToHands(value) {
+    this.dmToHands = value;
+  }
+
+  setDmAnnotation(value) {
+    this.dmAnnotation = value;
+  }
+
+  setDmRecipientRefNumber(value) {
+    this.dmRecipientRefNumber = value;
+  }
+
+  setDmSenderRefNumber(value) {
+    this.dmSenderRefNumber = value;
+  }
+
+  setDmRecipientIdent(value) {
+    this.dmRecipientIdent = value;
+  }
+
+  setDmSenderIdent(value) {
+    this.dmSenderIdent = value;
+  }
+
+  setDmLegalTitleLaw(value) {
+    this.dmLegalTitleLaw = value;
+  }
+
+  setDmLegalTitleYear(value) {
+    this.dmLegalTitleYear = value;
+  }
+
+  setDmLegalTitleSect(value) {
+    this.dmLegalTitleSect = value;
+  }
+
+  setDmLegalTitlePar(value) {
+    this.dmLegalTitlePar = value;
+  }
+
+  setDmLegalTitlePoint(value) {
+    this.dmLegalTitlePoint = value;
+  }
+
+  setDmPersonalDelivery(value) {
+    this.dmPersonalDelivery = value;
+  }
+
+  setDmAllowSubstDelivery(value) {
+    this.dmAllowSubstDelivery = value;
+  }
+
+  setDmOVM(value) {
+    this.dmOVM = value;
+  }
+
+  setDmPublishOwnID(value) {
+    this.dmPublishOwnID = value;
+  }
+
+  build() {
+    return {
+      dmSenderOrgUnit: this.dmSenderOrgUnit,
+      dmSenderOrgUnitNum: this.dmSenderOrgUnitNum,
+      dbIDRecipient: this.dbIDRecipient,
+      dmRecipientOrgUnit: this.dmRecipientOrgUnit,
+      dmRecipientOrgUnitNum: this.dmRecipientOrgUnitNum,
+      dmToHands: this.dmToHands,
+      dmAnnotation: this.dmAnnotation,
+      dmRecipientRefNumber: this.dmRecipientRefNumber,
+      dmSenderRefNumber: this.dmSenderRefNumber,
+      dmRecipientIdent: this.dmRecipientIdent,
+      dmSenderIdent: this.dmSenderIdent,
+      dmLegalTitleLaw: this.dmLegalTitleLaw,
+      dmLegalTitleYear: this.dmLegalTitleYear,
+      dmLegalTitleSect: this.dmLegalTitleSect,
+      dmLegalTitlePar: this.dmLegalTitlePar,
+      dmLegalTitlePoint: this.dmLegalTitlePoint,
+      dmPersonalDelivery: this.dmPersonalDelivery,
+      dmAllowSubstDelivery: this.dmAllowSubstDelivery,
+      dmOVM: this.dmOVM,
+      dmPublishOwnID: this.dmPublishOwnID,
+    };
+  }
+}
+
+export default DataMessage;

package/src/models/DataMessageFile.js

@@ -0,0 +1,69 @@
+class DataMessageFile {
+  constructor() {
+    this.dmEncodedContent = null;
+    this.dmXMLContent = null;
+    this.dmMimeType = null;
+    this.dmFileMetaType = null;
+    this.dmFileDescr = null;
+    this.dmFileGuid = null;
+    this.dmUpFileGuid = null;
+    this.dmFormat = null;
+  }
+
+  setDmEncodedContent(value) {
+    this.dmEncodedContent = value;
+  }
+
+  setDmXMLContent(value) {
+    this.dmXMLContent = value;
+  }
+
+  setDmMimeType(value) {
+    this.dmMimeType = value;
+  }
+
+  setDmFileMetaType(value) {
+    this.dmFileMetaType = value;
+  }
+
+  setDmFileDescr(value) {
+    this.dmFileDescr = value;
+  }
+
+  setDmFileGuid(value) {
+    this.dmFileGuid = value;
+  }
+
+  setDmUpFileGuid(value) {
+    this.dmUpFileGuid = value;
+  }
+
+  setDmFormat(value) {
+    this.dmFormat = value;
+  }
+
+  build() {
+    const attributes = {
+      dmMimeType: this.dmMimeType || '',
+      dmFileMetaType: this.dmFileMetaType || '',
+      dmFileDescr: this.dmFileDescr || '',
+      dmFileGuid: this.dmFileGuid || '',
+      dmUpFileGuid: this.dmUpFileGuid || '',
+      dmFormat: this.dmFormat || '',
+    };
+
+    const fileObject = {
+      attributes: attributes,
+    };
+
+    if (this.dmEncodedContent) {
+      fileObject.dmEncodedContent = this.dmEncodedContent;
+    } else if (this.dmXMLContent) {
+      fileObject.dmXMLContent = this.dmXMLContent;
+    }
+
+    return fileObject;
+  }
+}
+
+export default DataMessageFile;

package/src/models/DataMessageFiles.js

@@ -0,0 +1,23 @@
+import DataMessageFile from './DataMessageFile.js';
+
+class DataMessageFiles {
+  constructor() {
+    this.files = [];
+  }
+
+  addFile(file) {
+    if (file instanceof DataMessageFile) {
+      this.files.push(file.build());
+    } else {
+      throw new Error('Invalid file type');
+    }
+  }
+
+  build() {
+    return {
+      dmFile: this.files,
+    };
+  }
+}
+
+export default DataMessageFiles;